Update seed to do bulk insert

src/hooks/useBeerPostComments.ts

@@ -54,8 +54,6 @@ const useBeerPostComments = ({ id, pageSize }: UseBeerPostCommentsProps) => {
 
   const isAtEnd = !(size < data?.[0].pageCount!);
 
-  console.log(comments);
-
   return {
     comments,
     isLoading,

src/prisma/seed/create/createNewBeerImages.ts

@@ -1,6 +1,6 @@
 // eslint-disable-next-line import/no-extraneous-dependencies
 import { faker } from '@faker-js/faker';
-import { BeerPost, BeerImage, User } from '@prisma/client';
+import { BeerPost, User } from '@prisma/client';
 import DBClient from '../../DBClient';
 
 interface CreateNewBeerImagesArgs {
@@ -8,13 +8,22 @@ interface CreateNewBeerImagesArgs {
   joinData: { beerPosts: BeerPost[]; users: User[] };
 }
 
+interface BeerImageData {
+  path: string;
+  alt: string;
+  caption: string;
+  beerPostId: string;
+  postedById: string;
+  createdAt: Date;
+}
 const createNewBeerImages = async ({
   numberOfImages,
   joinData: { beerPosts, users },
 }: CreateNewBeerImagesArgs) => {
   const prisma = DBClient.instance;
   const createdAt = faker.date.past(1);
-  const beerImagesPromises: Promise<BeerImage>[] = [];
+
+  const beerImageData: BeerImageData[] = [];
 
   // eslint-disable-next-line no-plusplus
   for (let i = 0; i < numberOfImages; i++) {
@@ -23,21 +32,18 @@ const createNewBeerImages = async ({
     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,
-        },
-      }),
-    );
+    beerImageData.push({
+      path: 'https://picsum.photos/5000/5000',
+      alt,
+      caption,
+      beerPostId: beerPost.id,
+      postedById: user.id,
+      createdAt,
+    });
   }
 
-  return Promise.all(beerImagesPromises);
+  await prisma.beerImage.createMany({ data: beerImageData });
+  return prisma.beerImage.findMany();
 };
 
 export default createNewBeerImages;

src/prisma/seed/create/createNewBeerPostComments.ts

@@ -1,6 +1,6 @@
 // eslint-disable-next-line import/no-extraneous-dependencies
 import { faker } from '@faker-js/faker';
-import { BeerComment, BeerPost, User } from '@prisma/client';
+import { BeerPost, User } from '@prisma/client';
 
 import DBClient from '../../DBClient';
 
@@ -11,32 +11,46 @@ interface CreateNewBeerCommentsArgs {
     users: User[];
   };
 }
+
+interface BeerCommentData {
+  content: string;
+  postedById: string;
+  beerPostId: string;
+  rating: number;
+  createdAt: Date;
+}
+
 const createNewBeerComments = async ({
   numberOfComments,
   joinData,
 }: CreateNewBeerCommentsArgs) => {
   const { beerPosts, users } = joinData;
   const prisma = DBClient.instance;
-  const beerCommentPromises: Promise<BeerComment>[] = [];
+
+  const beerCommentData: BeerCommentData[] = [];
+
   // 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,
-        },
-      }),
-    );
+    const rating = Math.floor(Math.random() * 5) + 1;
+
+    beerCommentData.push({
+      content,
+      postedById: user.id,
+      beerPostId: beerPost.id,
+      createdAt,
+      rating,
+    });
   }
-  return Promise.all(beerCommentPromises);
+
+  await prisma.beerComment.createMany({
+    data: beerCommentData,
+  });
+
+  return prisma.beerComment.findMany();
 };
 
 export default createNewBeerComments;

src/prisma/seed/create/createNewBeerPostLikes.ts

@@ -1,34 +1,36 @@
-import type { BeerPost, BeerPostLike, User } from '@prisma/client';
+import type { BeerPost, User } from '@prisma/client';
+
 import DBClient from '../../DBClient';
 
+interface BeerPostLikeData {
+  beerPostId: string;
+  likedById: string;
+}
+
 const createNewBeerPostLikes = async ({
   joinData: { beerPosts, users },
   numberOfLikes,
 }: {
-  joinData: {
-    beerPosts: BeerPost[];
-    users: User[];
-  };
+  joinData: { beerPosts: BeerPost[]; users: User[] };
   numberOfLikes: number;
 }) => {
-  const beerPostLikePromises: Promise<BeerPostLike>[] = [];
-
+  const beerPostLikeData: BeerPostLikeData[] = [];
   // 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 } },
-        },
-      }),
-    );
+    beerPostLikeData.push({
+      beerPostId: beerPost.id,
+      likedById: user.id,
+    });
   }
 
-  return Promise.all(beerPostLikePromises);
+  await DBClient.instance.beerPostLike.createMany({
+    data: beerPostLikeData,
+  });
+
+  return DBClient.instance.beerPostLike.findMany();
 };
 
 export default createNewBeerPostLikes;

src/prisma/seed/create/createNewBeerPosts.ts

@@ -13,13 +13,24 @@ interface CreateNewBeerPostsArgs {
   };
 }
 
+interface BeerPostData {
+  abv: number;
+  ibu: number;
+  name: string;
+  description: string;
+  createdAt: Date;
+  breweryId: string;
+  postedById: string;
+  typeId: string;
+}
+
 const createNewBeerPosts = async ({
   numberOfPosts,
   joinData,
 }: CreateNewBeerPostsArgs) => {
   const { users, breweryPosts, beerTypes } = joinData;
   const prisma = DBClient.instance;
-  const beerPostPromises = [];
+  const beerPostData: BeerPostData[] = [];
   // eslint-disable-next-line no-plusplus
   for (let i = 0; i < numberOfPosts; i++) {
     const user = users[Math.floor(Math.random() * users.length)];
@@ -32,22 +43,20 @@ const createNewBeerPosts = async ({
     const name = faker.commerce.productName();
     const description = faker.lorem.lines(20).replace(/(\r\n|\n|\r)/gm, ' ');
 
-    beerPostPromises.push(
-      prisma.beerPost.create({
-        data: {
-          abv,
-          ibu,
-          name,
-          description,
-          createdAt,
-          brewery: { connect: { id: breweryPost.id } },
-          postedBy: { connect: { id: user.id } },
-          type: { connect: { id: beerType.id } },
-        },
-      }),
-    );
+    beerPostData.push({
+      postedById: user.id,
+      typeId: beerType.id,
+      breweryId: breweryPost.id,
+      createdAt,
+      abv,
+      ibu,
+      name,
+      description,
+    });
   }
-  return Promise.all(beerPostPromises);
+
+  await prisma.beerPost.createMany({ data: beerPostData });
+  return prisma.beerPost.findMany();
 };
 
 export default createNewBeerPosts;

src/prisma/seed/create/createNewBeerTypes.ts

@@ -1,6 +1,6 @@
 // eslint-disable-next-line import/no-extraneous-dependencies
 import { faker } from '@faker-js/faker';
-import { User, BeerType } from '@prisma/client';
+import { User } from '@prisma/client';
 import DBClient from '../../DBClient';
 
 interface CreateNewBeerTypesArgs {
@@ -9,10 +9,17 @@ interface CreateNewBeerTypesArgs {
   };
 }
 
+interface BeerTypeData {
+  name: string;
+  postedById: string;
+  createdAt: Date;
+}
+
 const createNewBeerTypes = async ({ joinData }: CreateNewBeerTypesArgs) => {
   const { users } = joinData;
   const prisma = DBClient.instance;
-  const beerTypePromises: Promise<BeerType>[] = [];
+
+  const beerTypeData: BeerTypeData[] = [];
 
   const types = [
     'IPA',
@@ -39,14 +46,16 @@ const createNewBeerTypes = async ({ joinData }: CreateNewBeerTypesArgs) => {
   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 },
-      }),
-    );
+
+    beerTypeData.push({
+      name: type,
+      postedById: user.id,
+      createdAt,
+    });
   });
 
-  return Promise.all(beerTypePromises);
+  await prisma.beerType.createMany({ data: beerTypeData, skipDuplicates: true });
+  return prisma.beerType.findMany();
 };
 
 export default createNewBeerTypes;

src/prisma/seed/create/createNewBreweryImages.ts

@@ -1,6 +1,6 @@
 // eslint-disable-next-line import/no-extraneous-dependencies
 import { faker } from '@faker-js/faker';
-import { BreweryPost, BreweryImage, User } from '@prisma/client';
+import { BreweryPost, User } from '@prisma/client';
 import DBClient from '../../DBClient';
 
 interface CreateBreweryImagesArgs {
@@ -11,34 +11,42 @@ interface CreateBreweryImagesArgs {
     users: User[];
   };
 }
+interface BreweryImageData {
+  path: string;
+  alt: string;
+  caption: string;
+  breweryPostId: string;
+  postedById: string;
+  createdAt: Date;
+}
+
 const createNewBreweryImages = async ({
   numberOfImages,
   joinData: { breweryPosts, users },
 }: CreateBreweryImagesArgs) => {
   const prisma = DBClient.instance;
   const createdAt = faker.date.past(1);
-  const breweryImagesPromises: Promise<BreweryImage>[] = [];
+  const breweryImageData: BreweryImageData[] = [];
 
   // 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,
-        },
-      }),
-    );
+    breweryImageData.push({
+      path: 'https://picsum.photos/5000/5000',
+      alt: 'Placeholder brewery image.',
+      caption: 'Placeholder brewery image caption.',
+      breweryPostId: breweryPost.id,
+      postedById: user.id,
+      createdAt,
+    });
   }
 
-  return Promise.all(breweryImagesPromises);
-};
+  await prisma.breweryImage.createMany({
+    data: breweryImageData,
+  });
 
+  return prisma.breweryImage.findMany();
+};
 export default createNewBreweryImages;

src/prisma/seed/create/createNewBreweryPostComments.ts

@@ -1,6 +1,6 @@
 // eslint-disable-next-line import/no-extraneous-dependencies
 import { faker } from '@faker-js/faker';
-import { BreweryComment, BreweryPost, User } from '@prisma/client';
+import { BreweryPost, User } from '@prisma/client';
 import DBClient from '../../DBClient';
 
 interface CreateNewBreweryPostCommentsArgs {
@@ -11,32 +11,40 @@ interface CreateNewBreweryPostCommentsArgs {
   };
 }
 
+interface BreweryPostCommentData {
+  content: string;
+  postedById: string;
+  breweryPostId: string;
+  rating: number;
+  createdAt: Date;
+}
+
 const createNewBreweryPostComments = async ({
   numberOfComments,
   joinData,
 }: CreateNewBreweryPostCommentsArgs) => {
   const { breweryPosts, users } = joinData;
   const prisma = DBClient.instance;
-  const breweryCommentPromises: Promise<BreweryComment>[] = [];
+  const breweryPostCommentData: BreweryPostCommentData[] = [];
   const createdAt = faker.date.past(1);
+  const rating = Math.floor(Math.random() * 5) + 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,
-        },
-      }),
-    );
+
+    breweryPostCommentData.push({
+      content,
+      createdAt,
+      rating,
+      postedById: user.id,
+      breweryPostId: breweryPost.id,
+    });
   }
-  return Promise.all(breweryCommentPromises);
+  await prisma.breweryComment.createMany({ data: breweryPostCommentData });
+
+  return prisma.breweryComment.findMany();
 };
 
 export default createNewBreweryPostComments;

src/prisma/seed/create/createNewBreweryPostLikes.ts

@@ -1,6 +1,11 @@
-import type { BreweryPost, BreweryPostLike, User } from '@prisma/client';
+import type { BreweryPost, User } from '@prisma/client';
 import DBClient from '../../DBClient';
 
+interface BreweryPostLikeData {
+  breweryPostId: string;
+  likedById: string;
+}
+
 const createNewBreweryPostLikes = async ({
   joinData: { breweryPosts, users },
   numberOfLikes,
@@ -11,23 +16,22 @@ const createNewBreweryPostLikes = async ({
   };
   numberOfLikes: number;
 }) => {
-  const breweryPostLikePromises: Promise<BreweryPostLike>[] = [];
+  const breweryPostLikeData: BreweryPostLikeData[] = [];
   // eslint-disable-next-line no-plusplus
   for (let i = 0; i < numberOfLikes; i++) {
     const breweryPost = breweryPosts[Math.floor(Math.random() * breweryPosts.length)];
     const user = users[Math.floor(Math.random() * users.length)];
 
-    breweryPostLikePromises.push(
-      DBClient.instance.breweryPostLike.create({
-        data: {
-          breweryPost: { connect: { id: breweryPost.id } },
-          likedBy: { connect: { id: user.id } },
-        },
-      }),
-    );
+    breweryPostLikeData.push({
+      breweryPostId: breweryPost.id,
+      likedById: user.id,
+    });
   }
+  await DBClient.instance.breweryPostLike.createMany({
+    data: breweryPostLikeData,
+  });
 
-  return Promise.all(breweryPostLikePromises);
+  return DBClient.instance.breweryPostLike.findMany();
 };
 
 export default createNewBreweryPostLikes;

src/prisma/seed/create/createNewBreweryPosts.ts

@@ -11,6 +11,15 @@ interface CreateNewBreweryPostsArgs {
   };
 }
 
+interface BreweryData {
+  name: string;
+  locationId: string;
+  description: string;
+  postedById: string;
+  createdAt: Date;
+  dateEstablished: Date;
+}
+
 const createNewBreweryPosts = async ({
   numberOfPosts,
   joinData,
@@ -18,7 +27,7 @@ const createNewBreweryPosts = async ({
   const { users, locations } = joinData;
 
   const prisma = DBClient.instance;
-  const breweryPromises = [];
+  const breweryData: BreweryData[] = [];
   // eslint-disable-next-line no-plusplus
   for (let i = 0; i < numberOfPosts; i++) {
     const name = `${faker.commerce.productName()} Brewing Company`;
@@ -30,20 +39,18 @@ const createNewBreweryPosts = async ({
     const createdAt = faker.date.past(1);
     const dateEstablished = faker.date.past(40);
 
-    breweryPromises.push(
-      prisma.breweryPost.create({
-        data: {
-          name,
-          description,
-          createdAt,
-          dateEstablished,
-          postedBy: { connect: { id: user.id } },
-          location: { connect: { id: location.id } },
-        },
-      }),
-    );
+    breweryData.push({
+      name,
+      locationId: location.id,
+      description,
+      postedById: user.id,
+      createdAt,
+      dateEstablished,
+    });
   }
-  return Promise.all(breweryPromises);
+  await prisma.breweryPost.createMany({ data: breweryData, skipDuplicates: true });
+
+  return prisma.breweryPost.findMany();
 };
 
 export default createNewBreweryPosts;

src/prisma/seed/create/createNewLocations.ts

@@ -1,6 +1,6 @@
 /* eslint-disable import/no-extraneous-dependencies */
 import { faker } from '@faker-js/faker';
-import { User, Location } from '@prisma/client';
+import { User } from '@prisma/client';
 import { GeocodeFeature } from '@mapbox/mapbox-sdk/services/geocoding';
 import DBClient from '../../DBClient';
 import geocode from '../../../config/mapbox/geocoder';
@@ -12,6 +12,15 @@ interface CreateNewLocationsArgs {
   };
 }
 
+interface LocationData {
+  city: string;
+  stateOrProvince?: string;
+  country?: string;
+  coordinates: number[];
+  address: string;
+  postedById: string;
+}
+
 const createNewLocations = async ({
   numberOfLocations,
   joinData,
@@ -33,31 +42,31 @@ const createNewLocations = async ({
 
   const geocodedLocations = await Promise.all(geocodePromises);
 
-  const locationPromises: Promise<Location>[] = [];
+  const locationData: LocationData[] = [];
 
   geocodedLocations.forEach((geodata) => {
+    const randomUser = joinData.users[Math.floor(Math.random() * joinData.users.length)];
+
     const city = geodata.text;
-    const user = joinData.users[Math.floor(Math.random() * joinData.users.length)];
+    const postedById = randomUser.id;
     const stateOrProvince = geodata.context?.find((c) => c.id.startsWith('region'))?.text;
     const country = geodata.context?.find((c) => c.id.startsWith('country'))?.text;
     const coordinates = geodata.center;
     const address = geodata.place_name;
 
-    locationPromises.push(
-      prisma.location.create({
-        data: {
-          city,
-          stateOrProvince,
-          country,
-          coordinates,
-          address,
-          postedBy: { connect: { id: user.id } },
-        },
-      }),
-    );
+    locationData.push({
+      city,
+      stateOrProvince,
+      country,
+      coordinates,
+      address,
+      postedById,
+    });
   });
 
-  return Promise.all(locationPromises);
+  await prisma.location.createMany({ data: locationData, skipDuplicates: true });
+
+  return prisma.location.findMany();
 };
 
 export default createNewLocations;

src/prisma/seed/create/createNewUsers.ts

@@ -8,55 +8,42 @@ interface CreateNewUsersArgs {
   numberOfUsers: number;
 }
 
+interface UserData {
+  firstName: string;
+  lastName: string;
+  email: string;
+  username: string;
+  dateOfBirth: Date;
+  createdAt: Date;
+  hash: string;
+}
+
 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())),
   );
 
-  const takenEmails: string[] = [];
-  const takenUsernames: string[] = [];
+  const data: UserData[] = [];
 
   // eslint-disable-next-line no-plusplus
   for (let i = 0; i < numberOfUsers; i++) {
-    const randomValue = crypto.randomBytes(10).toString('hex');
+    const randomValue = crypto.randomBytes(4).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 usernameTaken = takenUsernames.includes(username);
-    const emailTaken = takenEmails.includes(email);
-
-    if (usernameTaken || emailTaken) {
-      i -= 1;
-      // eslint-disable-next-line no-continue
-      continue;
-    }
-
-    takenEmails.push(email);
-    takenUsernames.push(username);
-
     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,
-        },
-      }),
-    );
+
+    const user = { firstName, lastName, email, username, dateOfBirth, createdAt, hash };
+    data.push(user);
   }
-  return Promise.all(userPromises);
+
+  await prisma.user.createMany({ data, skipDuplicates: true });
+  return prisma.user.findMany();
 };
 
 export default createNewUsers;

src/prisma/seed/index.ts

@@ -1,6 +1,5 @@
 import { performance } from 'perf_hooks';
-
-import logger from '../../config/pino/logger';
+import { exit } from 'process';
 
 import cleanDatabase from './clean/cleanDatabase';
 
@@ -15,6 +14,7 @@ import createNewBreweryPosts from './create/createNewBreweryPosts';
 import createNewUsers from './create/createNewUsers';
 import createNewBreweryPostLikes from './create/createNewBreweryPostLikes';
 import createNewLocations from './create/createNewLocations';
+import logger from '../../config/pino/logger';
 
 (async () => {
   try {
@@ -22,36 +22,30 @@ import createNewLocations from './create/createNewLocations';
 
     logger.info('Clearing database.');
     await cleanDatabase();
-
     logger.info('Database cleared successfully, preparing to seed.');
 
-    const users = await createNewUsers({ numberOfUsers: 1000 });
+    const users = await createNewUsers({ numberOfUsers: 10000 });
     logger.info('Users created successfully.');
-    console.log(users);
 
     const locations = await createNewLocations({
-      numberOfLocations: 1500,
+      numberOfLocations: 150,
       joinData: { users },
     });
     logger.info('Locations created successfully.');
 
     const [breweryPosts, beerTypes] = await Promise.all([
-      createNewBreweryPosts({ numberOfPosts: 1300, joinData: { users, locations } }),
+      createNewBreweryPosts({ numberOfPosts: 130, joinData: { users, locations } }),
       createNewBeerTypes({ joinData: { users } }),
     ]);
     logger.info('Brewery posts and beer types created successfully.');
+
     const beerPosts = await createNewBeerPosts({
       numberOfPosts: 200,
       joinData: { breweryPosts, beerTypes, users },
     });
     logger.info('Beer posts created successfully.');
-    const [
-      beerPostComments,
-      breweryPostComments,
-      beerPostLikes,
-      beerImages,
-      breweryImages,
-    ] = await Promise.all([
+
+    const [beerPostComments, breweryPostComments] = await Promise.all([
       createNewBeerPostComments({
         numberOfComments: 45000,
         joinData: { beerPosts, users },
@@ -60,6 +54,10 @@ import createNewLocations from './create/createNewLocations';
         numberOfComments: 45000,
         joinData: { breweryPosts, users },
       }),
+    ]);
+    logger.info('Created beer post comments and brewery post comments.');
+
+    const [beerPostLikes, breweryPostLikes] = await Promise.all([
       createNewBeerPostLikes({
         numberOfLikes: 10000,
         joinData: { beerPosts, users },
@@ -68,43 +66,43 @@ import createNewLocations from './create/createNewLocations';
         numberOfLikes: 10000,
         joinData: { breweryPosts, users },
       }),
+    ]);
+    logger.info('Created beer post likes, and brewery post likes.');
+
+    const [beerImages, breweryImages] = await Promise.all([
       createNewBeerImages({
-        numberOfImages: 1000,
+        numberOfImages: 100000,
         joinData: { beerPosts, users },
       }),
       createNewBreweryImages({
-        numberOfImages: 1000,
+        numberOfImages: 100000,
         joinData: { breweryPosts, users },
       }),
     ]);
-
-    logger.info(
-      'Beer post comments, brewery post comments, beer post likes, beer images, and brewery images created successfully.',
-    );
+    logger.info('Created beer images and brewery images.');
 
     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,
+      numberofBreweryPostLikes: breweryPostLikes.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);
+    exit(0);
   } catch (error) {
     logger.error('Error seeding database.');
     logger.error(error);
-    process.exit(1);
+    exit(1);
   }
 })();