scaffold create/edit beer form, scaffold beer page

prisma/seed/create/createNewBeerImages.ts

@@ -0,0 +1,32 @@
+import { BeerPost, BeerImage } from '@prisma/client';
+import DBClient from '../../DBClient';
+
+interface CreateNewBeerImagesArgs {
+  numberOfImages: number;
+  beerPosts: BeerPost[];
+}
+const createNewBeerImages = async ({
+  numberOfImages,
+  beerPosts,
+}: CreateNewBeerImagesArgs) => {
+  const prisma = DBClient.instance;
+
+  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)];
+    beerImagesPromises.push(
+      prisma.beerImage.create({
+        data: {
+          url: 'https://picsum.photos/900/1600',
+          beerPost: { connect: { id: beerPost.id } },
+        },
+      }),
+    );
+  }
+
+  return Promise.all(beerImagesPromises);
+};
+
+export default createNewBeerImages;

prisma/seed/create/createNewBeerPosts.ts

@@ -32,7 +32,7 @@ const createNewBeerPosts = async ({
           abv: 10,
           ibu: 10,
           name: `${faker.commerce.productName()} ${beerType.name}`,
-          description: faker.lorem.lines(),
+          description: faker.lorem.lines(24),
           brewery: { connect: { id: breweryPost.id } },
           postedBy: { connect: { id: user.id } },
           type: { connect: { id: beerType.id } },

prisma/seed/create/createNewBreweryImages.ts

@@ -0,0 +1,33 @@
+import { BreweryPost, BreweryImage } from '@prisma/client';
+import DBClient from '../../DBClient';
+
+interface CreateBreweryImagesArgs {
+  numberOfImages: number;
+  breweryPosts: BreweryPost[];
+}
+const createNewBreweryImages = async ({
+  numberOfImages,
+  breweryPosts,
+}: CreateBreweryImagesArgs) => {
+  const prisma = DBClient.instance;
+
+  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)];
+
+    breweryImagesPromises.push(
+      prisma.breweryImage.create({
+        data: {
+          url: 'https://picsum.photos/900/1600',
+          breweryPost: { connect: { id: breweryPost.id } },
+        },
+      }),
+    );
+  }
+
+  return Promise.all(breweryImagesPromises);
+};
+
+export default createNewBreweryImages;

prisma/seed/index.ts

@@ -1,37 +1,36 @@
+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 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 {
-    logger.info('Cleaning database...');
+    const start = performance.now();
+
+    logger.info('Clearing 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`);
+    logger.info('Database cleared successfully, preparing to seed.');
 
+    const users = await createNewUsers({ numberOfUsers: 1000 });
+    const [breweryPosts, beerTypes] = await Promise.all([
+      createNewBreweryPosts({ numberOfPosts: 10000, joinData: { users } }),
+      createNewBeerTypes({ joinData: { users } }),
+    ]);
     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,
@@ -42,13 +41,33 @@ import createNewUsers from './create/createNewUsers';
         joinData: { breweryPosts, users },
       }),
     ]);
-    logger.info(`Created ${beerPostComments.length} beer post comments`);
-    logger.info(`Created ${breweryPostComments.length} brewery post comments`);
 
-    logger.info('Database seeded successfully');
+    const [beerImages, breweryImages] = await Promise.all([
+      createNewBeerImages({ numberOfImages: 1000, beerPosts }),
+      createNewBreweryImages({ numberOfImages: 1000, breweryPosts }),
+    ]);
+
+    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,
+      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 seeding database.');
     logger.error(error);
     process.exit(1);
   }