Edit seed db function

prisma/seed/clean/cleanDatabase.ts

@@ -0,0 +1,13 @@
+import DBClient from '../../DBClient';
+
+const cleanDatabase = async () => {
+  const prisma = DBClient.instance;
+  await prisma.$executeRaw`TRUNCATE TABLE "User" CASCADE`;
+  await prisma.$executeRaw`TRUNCATE TABLE "BeerPost" CASCADE`;
+  await prisma.$executeRaw`TRUNCATE TABLE "BeerType" CASCADE`;
+  await prisma.$executeRaw`TRUNCATE TABLE "BreweryPost" CASCADE`;
+  await prisma.$executeRaw`TRUNCATE TABLE "BeerComment" CASCADE`;
+  await prisma.$executeRaw`TRUNCATE TABLE "BreweryComment" CASCADE`;
+};
+
+export default cleanDatabase;

prisma/seed/create/createNewBeerPostComments.ts

@@ -0,0 +1,39 @@
+// eslint-disable-next-line import/no-extraneous-dependencies
+import { faker } from '@faker-js/faker';
+import { BeerComment, BeerPost, User } from '@prisma/client';
+
+import DBClient from '../../DBClient';
+
+interface CreateNewBeerCommentsArgs {
+  numberOfComments: number;
+  joinData: {
+    beerPosts: BeerPost[];
+    users: User[];
+  };
+}
+const createNewBeerComments = async ({
+  numberOfComments,
+  joinData,
+}: CreateNewBeerCommentsArgs) => {
+  const { beerPosts, users } = joinData;
+  const prisma = DBClient.instance;
+  const beerCommentPromises: Promise<BeerComment>[] = [];
+  // eslint-disable-next-line no-plusplus
+  for (let i = 0; i < numberOfComments; i++) {
+    const content = faker.lorem.lines(5);
+    const user = users[Math.floor(Math.random() * users.length)];
+    const beerPost = beerPosts[Math.floor(Math.random() * beerPosts.length)];
+    beerCommentPromises.push(
+      prisma.beerComment.create({
+        data: {
+          content,
+          postedBy: { connect: { id: user.id } },
+          beerPost: { connect: { id: beerPost.id } },
+        },
+      }),
+    );
+  }
+  return Promise.all(beerCommentPromises);
+};
+
+export default createNewBeerComments;

prisma/seed/create/createNewBeerPosts.ts

@@ -0,0 +1,46 @@
+// eslint-disable-next-line import/no-extraneous-dependencies
+import { faker } from '@faker-js/faker';
+
+import { User, BeerType, BreweryPost } from '@prisma/client';
+import DBClient from '../../DBClient';
+
+interface CreateNewBeerPostsArgs {
+  numberOfPosts: number;
+  joinData: {
+    users: User[];
+    breweryPosts: BreweryPost[];
+    beerTypes: BeerType[];
+  };
+}
+
+const createNewBeerPosts = async ({
+  numberOfPosts,
+  joinData,
+}: CreateNewBeerPostsArgs) => {
+  const { users, breweryPosts, beerTypes } = joinData;
+  const prisma = DBClient.instance;
+  const beerPostPromises = [];
+  // eslint-disable-next-line no-plusplus
+  for (let i = 0; i < numberOfPosts; i++) {
+    const user = users[Math.floor(Math.random() * users.length)];
+    const beerType = beerTypes[Math.floor(Math.random() * beerTypes.length)];
+    const breweryPost = breweryPosts[Math.floor(Math.random() * breweryPosts.length)];
+
+    beerPostPromises.push(
+      prisma.beerPost.create({
+        data: {
+          abv: 10,
+          ibu: 10,
+          name: `${faker.commerce.productName()} ${beerType.name}`,
+          description: faker.lorem.lines(),
+          brewery: { connect: { id: breweryPost.id } },
+          postedBy: { connect: { id: user.id } },
+          type: { connect: { id: beerType.id } },
+        },
+      }),
+    );
+  }
+  return Promise.all(beerPostPromises);
+};
+
+export default createNewBeerPosts;

prisma/seed/create/createNewBeerTypes.ts

@@ -0,0 +1,49 @@
+import { User, BeerType } from '@prisma/client';
+import DBClient from '../../DBClient';
+
+interface CreateNewBeerTypesArgs {
+  joinData: {
+    users: User[];
+  };
+}
+
+const createNewBeerTypes = async ({ joinData }: CreateNewBeerTypesArgs) => {
+  const { users } = joinData;
+  const prisma = DBClient.instance;
+  const beerTypePromises: Promise<BeerType>[] = [];
+
+  const types = [
+    'IPA',
+    'Pilsner',
+    'Stout',
+    'Lager',
+    'Wheat Beer',
+    'Belgian Ale',
+    'Pale Ale',
+    'Brown Ale',
+    'Sour Beer',
+    'Porter',
+    'Bock',
+    'Rauchbier',
+    'Sasion',
+    'Kolsch',
+    'Helles',
+    'Weizenbock',
+    'Doppelbock',
+    'Eisbock',
+    'Barley Wine',
+  ];
+
+  types.forEach((type) => {
+    const user = users[Math.floor(Math.random() * users.length)];
+    beerTypePromises.push(
+      prisma.beerType.create({
+        data: { name: type, postedBy: { connect: { id: user.id } } },
+      }),
+    );
+  });
+
+  return Promise.all(beerTypePromises);
+};
+
+export default createNewBeerTypes;

prisma/seed/create/createNewBreweryPostComments.ts

@@ -0,0 +1,39 @@
+// eslint-disable-next-line import/no-extraneous-dependencies
+import { faker } from '@faker-js/faker';
+import { BreweryComment, BreweryPost, User } from '@prisma/client';
+import DBClient from '../../DBClient';
+
+interface CreateNewBreweryPostCommentsArgs {
+  numberOfComments: number;
+  joinData: {
+    breweryPosts: BreweryPost[];
+    users: User[];
+  };
+}
+
+const createNewBreweryPostComments = async ({
+  numberOfComments,
+  joinData,
+}: CreateNewBreweryPostCommentsArgs) => {
+  const { breweryPosts, users } = joinData;
+  const prisma = DBClient.instance;
+  const breweryCommentPromises: Promise<BreweryComment>[] = [];
+  // eslint-disable-next-line no-plusplus
+  for (let i = 0; i < numberOfComments; i++) {
+    const content = faker.lorem.lines(5);
+    const user = users[Math.floor(Math.random() * users.length)];
+    const breweryPost = breweryPosts[Math.floor(Math.random() * breweryPosts.length)];
+    breweryCommentPromises.push(
+      prisma.breweryComment.create({
+        data: {
+          content,
+          postedBy: { connect: { id: user.id } },
+          breweryPost: { connect: { id: breweryPost.id } },
+        },
+      }),
+    );
+  }
+  return Promise.all(breweryCommentPromises);
+};
+
+export default createNewBreweryPostComments;

prisma/seed/create/createNewBreweryPosts.ts

@@ -0,0 +1,36 @@
+// eslint-disable-next-line import/no-extraneous-dependencies
+import { faker } from '@faker-js/faker';
+import { User } from '@prisma/client';
+import DBClient from '../../DBClient';
+
+interface CreateNewBreweryPostsArgs {
+  numberOfPosts: number;
+  joinData: {
+    users: User[];
+  };
+}
+
+const createNewBreweryPosts = async ({
+  numberOfPosts,
+  joinData,
+}: CreateNewBreweryPostsArgs) => {
+  const { users } = joinData;
+  const prisma = DBClient.instance;
+  const breweryPromises = [];
+  // eslint-disable-next-line no-plusplus
+  for (let i = 0; i < numberOfPosts; i++) {
+    const name = `${faker.commerce.productName()} Brewing Company`;
+    const location = faker.address.cityName();
+    const description = faker.lorem.lines(5);
+    const user = users[Math.floor(Math.random() * users.length)];
+
+    breweryPromises.push(
+      prisma.breweryPost.create({
+        data: { name, location, description, postedBy: { connect: { id: user.id } } },
+      }),
+    );
+  }
+  return Promise.all(breweryPromises);
+};
+
+export default createNewBreweryPosts;

prisma/seed/create/createNewUsers.ts

@@ -0,0 +1,35 @@
+// eslint-disable-next-line import/no-extraneous-dependencies
+import { faker } from '@faker-js/faker';
+import DBClient from '../../DBClient';
+
+interface CreateNewUsersArgs {
+  numberOfUsers: number;
+}
+
+const createNewUsers = async ({ numberOfUsers }: CreateNewUsersArgs) => {
+  const prisma = DBClient.instance;
+  const userPromises = [];
+  // eslint-disable-next-line no-plusplus
+  for (let i = 0; i < numberOfUsers; i++) {
+    const firstName = faker.name.firstName();
+    const lastName = faker.name.lastName();
+    const username = `${firstName[0]}.${lastName}`;
+    const email = faker.internet.email(firstName, lastName, 'example.com');
+    const dateOfBirth = faker.date.birthdate({ mode: 'age', min: 19 });
+
+    userPromises.push(
+      prisma.user.create({
+        data: {
+          firstName,
+          lastName,
+          email,
+          username,
+          dateOfBirth,
+        },
+      }),
+    );
+  }
+  return Promise.all(userPromises);
+};
+
+export default createNewUsers;

prisma/seed/index.ts

@@ -0,0 +1,55 @@
+import logger from '../../config/pino/logger';
+
+import cleanDatabase from './clean/cleanDatabase';
+import createNewBeerPostComments from './create/createNewBeerPostComments';
+import createNewBeerPosts from './create/createNewBeerPosts';
+import createNewBeerTypes from './create/createNewBeerTypes';
+import createNewBreweryPostComments from './create/createNewBreweryPostComments';
+import createNewBreweryPosts from './create/createNewBreweryPosts';
+import createNewUsers from './create/createNewUsers';
+
+(async () => {
+  try {
+    logger.info('Cleaning database...');
+    await cleanDatabase();
+    logger.info('Database cleaned successfully, preparing to seed');
+
+    const users = await createNewUsers({ numberOfUsers: 10 });
+    logger.info(`Created ${users.length} users`);
+
+    const breweryPosts = await createNewBreweryPosts({
+      numberOfPosts: 100,
+      joinData: { users },
+    });
+    logger.info(`Created ${breweryPosts.length} brewery posts`);
+
+    const beerTypes = await createNewBeerTypes({ joinData: { users } });
+    logger.info(`Created ${beerTypes.length} beer types`);
+
+    const beerPosts = await createNewBeerPosts({
+      numberOfPosts: 100,
+      joinData: { breweryPosts, beerTypes, users },
+    });
+    logger.info(`Created ${beerPosts.length} beer posts`);
+
+    const [beerPostComments, breweryPostComments] = await Promise.all([
+      createNewBeerPostComments({
+        numberOfComments: 1000,
+        joinData: { beerPosts, users },
+      }),
+      createNewBreweryPostComments({
+        numberOfComments: 1000,
+        joinData: { breweryPosts, users },
+      }),
+    ]);
+    logger.info(`Created ${beerPostComments.length} beer post comments`);
+    logger.info(`Created ${breweryPostComments.length} brewery post comments`);
+
+    logger.info('Database seeded successfully');
+    process.exit(0);
+  } catch (error) {
+    logger.error('Error seeding database');
+    logger.error(error);
+    process.exit(1);
+  }
+})();