Work on brewery page, refactors

Refactor query types to explicitly use z.infer

pages/api/beers/[id]/comments/index.ts

@@ -1,21 +1,28 @@
+import DBClient from '@/prisma/DBClient';
+import getAllBeerComments from '@/services/BeerComment/getAllBeerComments';
 import validateRequest from '@/config/nextConnect/middleware/validateRequest';
 import APIResponseValidationSchema from '@/validation/APIResponseValidationSchema';
 import { UserExtendedNextApiRequest } from '@/config/auth/types';
 import NextConnectOptions from '@/config/nextConnect/NextConnectOptions';
 import createNewBeerComment from '@/services/BeerComment/createNewBeerComment';
-import { BeerCommentQueryResultT } from '@/services/BeerComment/schema/BeerCommentQueryResult';
+
 import BeerCommentValidationSchema from '@/services/BeerComment/schema/CreateBeerCommentValidationSchema';
 
 import { createRouter } from 'next-connect';
 import { z } from 'zod';
 import getCurrentUser from '@/config/nextConnect/middleware/getCurrentUser';
 import { NextApiResponse } from 'next';
+import BeerCommentQueryResult from '@/services/BeerComment/schema/BeerCommentQueryResult';
 
 interface CreateCommentRequest extends UserExtendedNextApiRequest {
   body: z.infer<typeof BeerCommentValidationSchema>;
   query: { id: string };
 }
 
+interface GetAllCommentsRequest extends UserExtendedNextApiRequest {
+  query: { id: string; page_size: string; page_num: string };
+}
+
 const createComment = async (
   req: CreateCommentRequest,
   res: NextApiResponse<z.infer<typeof APIResponseValidationSchema>>,
@@ -24,12 +31,13 @@ const createComment = async (
 
   const beerPostId = req.query.id;
 
-  const newBeerComment: BeerCommentQueryResultT = await createNewBeerComment({
-    content,
-    rating,
-    beerPostId,
-    userId: req.user!.id,
-  });
+  const newBeerComment: z.infer<typeof BeerCommentQueryResult> =
+    await createNewBeerComment({
+      content,
+      rating,
+      beerPostId,
+      userId: req.user!.id,
+    });
 
   res.status(201).json({
     message: 'Beer comment created successfully',
@@ -39,8 +47,34 @@ const createComment = async (
   });
 };
 
+const getAll = async (
+  req: GetAllCommentsRequest,
+  res: NextApiResponse<z.infer<typeof APIResponseValidationSchema>>,
+) => {
+  const beerPostId = req.query.id;
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  const { page_size, page_num } = req.query;
+
+  const comments = await getAllBeerComments(
+    { id: beerPostId },
+    { pageSize: parseInt(page_size, 10), pageNum: parseInt(page_num, 10) },
+  );
+
+  const pageCount = await DBClient.instance.beerComment.count({ where: { beerPostId } });
+
+  res.setHeader('X-Total-Count', pageCount);
+
+  res.status(200).json({
+    message: 'Beer comments fetched successfully',
+    statusCode: 200,
+    payload: comments,
+    success: true,
+  });
+};
+
 const router = createRouter<
-  CreateCommentRequest,
+  // I don't want to use any, but I can't figure out how to get the types to work
+  any,
   NextApiResponse<z.infer<typeof APIResponseValidationSchema>>
 >();
 
@@ -53,5 +87,16 @@ router.post(
   createComment,
 );
 
+router.get(
+  validateRequest({
+    querySchema: z.object({
+      id: z.string().uuid(),
+      page_size: z.coerce.number().int().positive(),
+      page_num: z.coerce.number().int().positive(),
+    }),
+  }),
+  getAll,
+);
+
 const handler = router.handler(NextConnectOptions);
 export default handler;

pages/api/beers/search.ts

@@ -5,7 +5,7 @@ import { NextApiRequest, NextApiResponse } from 'next';
 import { createRouter } from 'next-connect';
 import { z } from 'zod';
 import DBClient from '@/prisma/DBClient';
-import { BeerPostQueryResult } from '@/services/BeerPost/schema/BeerPostQueryResult';
+import beerPostQueryResult from '@/services/BeerPost/schema/BeerPostQueryResult';
 
 const SearchSchema = z.object({
   search: z.string().min(1),
@@ -18,29 +18,30 @@ interface SearchAPIRequest extends NextApiRequest {
 const search = async (req: SearchAPIRequest, res: NextApiResponse) => {
   const { search: query } = req.query;
 
-  const beers: BeerPostQueryResult[] = await DBClient.instance.beerPost.findMany({
-    select: {
-      id: true,
-      name: true,
-      ibu: true,
-      abv: true,
-      createdAt: true,
-      description: true,
-      postedBy: { select: { username: true, id: true } },
-      brewery: { select: { name: true, id: true } },
-      type: { select: { name: true, id: true } },
-      beerImages: { select: { alt: true, path: true, caption: true, id: true } },
-    },
-    where: {
-      OR: [
-        { name: { contains: query, mode: 'insensitive' } },
-        { description: { contains: query, mode: 'insensitive' } },
+  const beers: z.infer<typeof beerPostQueryResult>[] =
+    await DBClient.instance.beerPost.findMany({
+      select: {
+        id: true,
+        name: true,
+        ibu: true,
+        abv: true,
+        createdAt: true,
+        description: true,
+        postedBy: { select: { username: true, id: true } },
+        brewery: { select: { name: true, id: true } },
+        type: { select: { name: true, id: true } },
+        beerImages: { select: { alt: true, path: true, caption: true, id: true } },
+      },
+      where: {
+        OR: [
+          { name: { contains: query, mode: 'insensitive' } },
+          { description: { contains: query, mode: 'insensitive' } },
 
-        { brewery: { name: { contains: query, mode: 'insensitive' } } },
-        { type: { name: { contains: query, mode: 'insensitive' } } },
-      ],
-    },
-  });
+          { brewery: { name: { contains: query, mode: 'insensitive' } } },
+          { type: { name: { contains: query, mode: 'insensitive' } } },
+        ],
+      },
+    });
 
   res.status(200).json(beers);
 };