Restructure codebase to use src directory

src/prisma/seed/clean/cleanDatabase.ts

@@ -0,0 +1,18 @@
+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`;
+  await prisma.$executeRaw`TRUNCATE TABLE "BeerPostLike" CASCADE`;
+  await prisma.$executeRaw`TRUNCATE TABLE "BeerImage" CASCADE`;
+  await prisma.$executeRaw`TRUNCATE TABLE "BreweryImage" CASCADE`;
+
+  await prisma.$disconnect();
+};
+
+export default cleanDatabase;

src/prisma/seed/create/createNewBeerImages.ts

@@ -0,0 +1,43 @@
+// eslint-disable-next-line import/no-extraneous-dependencies
+import { faker } from '@faker-js/faker';
+import { BeerPost, BeerImage, User } from '@prisma/client';
+import DBClient from '../../DBClient';
+
+interface CreateNewBeerImagesArgs {
+  numberOfImages: number;
+  joinData: { beerPosts: BeerPost[]; users: User[] };
+}
+
+const createNewBeerImages = async ({
+  numberOfImages,
+  joinData: { beerPosts, users },
+}: CreateNewBeerImagesArgs) => {
+  const prisma = DBClient.instance;
+  const createdAt = faker.date.past(1);
+  const beerImagesPromises: Promise<BeerImage>[] = [];
+
+  // eslint-disable-next-line no-plusplus
+  for (let i = 0; i < numberOfImages; i++) {
+    const beerPost = beerPosts[Math.floor(Math.random() * beerPosts.length)];
+    const user = users[Math.floor(Math.random() * users.length)];
+    const caption = faker.lorem.sentence();
+    const alt = faker.lorem.sentence();
+
+    beerImagesPromises.push(
+      prisma.beerImage.create({
+        data: {
+          path: 'https://picsum.photos/5000/5000',
+          alt,
+          caption,
+          beerPost: { connect: { id: beerPost.id } },
+          postedBy: { connect: { id: user.id } },
+          createdAt,
+        },
+      }),
+    );
+  }
+
+  return Promise.all(beerImagesPromises);
+};
+
+export default createNewBeerImages;

src/prisma/seed/create/createNewBeerPostComments.ts

@@ -0,0 +1,42 @@
+// 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)];
+    const createdAt = faker.date.past(1);
+    beerCommentPromises.push(
+      prisma.beerComment.create({
+        data: {
+          content,
+          postedBy: { connect: { id: user.id } },
+          beerPost: { connect: { id: beerPost.id } },
+          rating: Math.floor(Math.random() * 5) + 1,
+          createdAt,
+        },
+      }),
+    );
+  }
+  return Promise.all(beerCommentPromises);
+};
+
+export default createNewBeerComments;

src/prisma/seed/create/createNewBeerPostLikes.ts

@@ -0,0 +1,34 @@
+import type { BeerPost, BeerPostLike, User } from '@prisma/client';
+import DBClient from '../../DBClient';
+
+const createNewBeerPostLikes = async ({
+  joinData: { beerPosts, users },
+  numberOfLikes,
+}: {
+  joinData: {
+    beerPosts: BeerPost[];
+    users: User[];
+  };
+  numberOfLikes: number;
+}) => {
+  const beerPostLikePromises: Promise<BeerPostLike>[] = [];
+
+  // eslint-disable-next-line no-plusplus
+  for (let i = 0; i < numberOfLikes; i++) {
+    const beerPost = beerPosts[Math.floor(Math.random() * beerPosts.length)];
+    const user = users[Math.floor(Math.random() * users.length)];
+
+    beerPostLikePromises.push(
+      DBClient.instance.beerPostLike.create({
+        data: {
+          beerPost: { connect: { id: beerPost.id } },
+          likedBy: { connect: { id: user.id } },
+        },
+      }),
+    );
+  }
+
+  return Promise.all(beerPostLikePromises);
+};
+
+export default createNewBeerPostLikes;

src/prisma/seed/create/createNewBeerPosts.ts

@@ -0,0 +1,47 @@
+// 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)];
+    const createdAt = faker.date.past(1);
+    beerPostPromises.push(
+      prisma.beerPost.create({
+        data: {
+          abv: Math.floor(Math.random() * (12 - 4) + 4),
+          ibu: Math.floor(Math.random() * (60 - 10) + 10),
+          name: faker.commerce.productName(),
+          description: faker.lorem.lines(12).replace(/(\r\n|\n|\r)/gm, ' '),
+          brewery: { connect: { id: breweryPost.id } },
+          postedBy: { connect: { id: user.id } },
+          type: { connect: { id: beerType.id } },
+          createdAt,
+        },
+      }),
+    );
+  }
+  return Promise.all(beerPostPromises);
+};
+
+export default createNewBeerPosts;

src/prisma/seed/create/createNewBeerTypes.ts

@@ -0,0 +1,52 @@
+// eslint-disable-next-line import/no-extraneous-dependencies
+import { faker } from '@faker-js/faker';
+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)];
+    const createdAt = faker.date.past(1);
+    beerTypePromises.push(
+      prisma.beerType.create({
+        data: { name: type, postedBy: { connect: { id: user.id } }, createdAt },
+      }),
+    );
+  });
+
+  return Promise.all(beerTypePromises);
+};
+
+export default createNewBeerTypes;

src/prisma/seed/create/createNewBreweryImages.ts

@@ -0,0 +1,44 @@
+// eslint-disable-next-line import/no-extraneous-dependencies
+import { faker } from '@faker-js/faker';
+import { BreweryPost, BreweryImage, User } from '@prisma/client';
+import DBClient from '../../DBClient';
+
+interface CreateBreweryImagesArgs {
+  numberOfImages: number;
+
+  joinData: {
+    breweryPosts: BreweryPost[];
+    users: User[];
+  };
+}
+const createNewBreweryImages = async ({
+  numberOfImages,
+  joinData: { breweryPosts, users },
+}: CreateBreweryImagesArgs) => {
+  const prisma = DBClient.instance;
+  const createdAt = faker.date.past(1);
+  const breweryImagesPromises: Promise<BreweryImage>[] = [];
+
+  // eslint-disable-next-line no-plusplus
+  for (let i = 0; i < numberOfImages; i++) {
+    const breweryPost = breweryPosts[Math.floor(Math.random() * breweryPosts.length)];
+    const user = users[Math.floor(Math.random() * users.length)];
+
+    breweryImagesPromises.push(
+      prisma.breweryImage.create({
+        data: {
+          path: 'https://picsum.photos/5000/5000',
+          alt: 'Placeholder brewery image.',
+          caption: 'Placeholder brewery image caption.',
+          breweryPost: { connect: { id: breweryPost.id } },
+          postedBy: { connect: { id: user.id } },
+          createdAt,
+        },
+      }),
+    );
+  }
+
+  return Promise.all(breweryImagesPromises);
+};
+
+export default createNewBreweryImages;

src/prisma/seed/create/createNewBreweryPostComments.ts

@@ -0,0 +1,42 @@
+// 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>[] = [];
+  const createdAt = faker.date.past(1);
+  // 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 } },
+          rating: Math.floor(Math.random() * 5) + 1,
+          createdAt,
+        },
+      }),
+    );
+  }
+  return Promise.all(breweryCommentPromises);
+};
+
+export default createNewBreweryPostComments;

src/prisma/seed/create/createNewBreweryPosts.ts

@@ -0,0 +1,42 @@
+// 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)];
+    const createdAt = faker.date.past(1);
+    breweryPromises.push(
+      prisma.breweryPost.create({
+        data: {
+          name,
+          location,
+          description,
+          postedBy: { connect: { id: user.id } },
+          createdAt,
+        },
+      }),
+    );
+  }
+  return Promise.all(breweryPromises);
+};
+
+export default createNewBreweryPosts;

src/prisma/seed/create/createNewUsers.ts

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

src/prisma/seed/index.ts

@@ -0,0 +1,90 @@
+import { performance } from 'perf_hooks';
+
+import logger from '../../config/pino/logger';
+
+import cleanDatabase from './clean/cleanDatabase';
+
+import createNewBeerImages from './create/createNewBeerImages';
+import createNewBeerPostComments from './create/createNewBeerPostComments';
+import createNewBeerPostLikes from './create/createNewBeerPostLikes';
+import createNewBeerPosts from './create/createNewBeerPosts';
+import createNewBeerTypes from './create/createNewBeerTypes';
+import createNewBreweryImages from './create/createNewBreweryImages';
+import createNewBreweryPostComments from './create/createNewBreweryPostComments';
+import createNewBreweryPosts from './create/createNewBreweryPosts';
+import createNewUsers from './create/createNewUsers';
+
+(async () => {
+  try {
+    const start = performance.now();
+
+    logger.info('Clearing database.');
+    await cleanDatabase();
+
+    logger.info('Database cleared successfully, preparing to seed.');
+
+    const users = await createNewUsers({ numberOfUsers: 1000 });
+    const [breweryPosts, beerTypes] = await Promise.all([
+      createNewBreweryPosts({ numberOfPosts: 100, joinData: { users } }),
+      createNewBeerTypes({ joinData: { users } }),
+    ]);
+    const beerPosts = await createNewBeerPosts({
+      numberOfPosts: 200,
+      joinData: { breweryPosts, beerTypes, users },
+    });
+
+    const [
+      beerPostComments,
+      breweryPostComments,
+      beerPostLikes,
+      beerImages,
+      breweryImages,
+    ] = await Promise.all([
+      createNewBeerPostComments({
+        numberOfComments: 45000,
+        joinData: { beerPosts, users },
+      }),
+      createNewBreweryPostComments({
+        numberOfComments: 45000,
+        joinData: { breweryPosts, users },
+      }),
+      createNewBeerPostLikes({
+        numberOfLikes: 10000,
+        joinData: { beerPosts, users },
+      }),
+      createNewBeerImages({
+        numberOfImages: 1000,
+        joinData: { beerPosts, users },
+      }),
+      createNewBreweryImages({
+        numberOfImages: 1000,
+        joinData: { breweryPosts, users },
+      }),
+    ]);
+
+    const end = performance.now();
+    const timeElapsed = (end - start) / 1000;
+
+    logger.info('Database seeded successfully.');
+
+    logger.info({
+      numberOfUsers: users.length,
+      numberOfBreweryPosts: breweryPosts.length,
+      numberOfBeerPosts: beerPosts.length,
+      numberOfBeerTypes: beerTypes.length,
+      numberOfBeerPostLikes: beerPostLikes.length,
+      numberOfBeerPostComments: beerPostComments.length,
+      numberOfBreweryPostComments: breweryPostComments.length,
+      numberOfBeerImages: beerImages.length,
+      numberOfBreweryImages: breweryImages.length,
+    });
+
+    logger.info(`Database seeded in ${timeElapsed.toFixed(2)} seconds.`);
+
+    process.exit(0);
+  } catch (error) {
+    logger.error('Error seeding database.');
+    logger.error(error);
+    process.exit(1);
+  }
+})();