Refactor and formatting

src/services/BeerComment/createNewBeerComment.ts

@@ -1,18 +1,21 @@
 import DBClient from '@/prisma/DBClient';
 import { z } from 'zod';
 import CreateCommentValidationSchema from '../schema/CommentSchema/CreateCommentValidationSchema';
+import BeerCommentQueryResult from './schema/BeerCommentQueryResult';
 
 const CreateNewBeerCommentServiceSchema = CreateCommentValidationSchema.extend({
   userId: z.string().cuid(),
   beerPostId: z.string().cuid(),
 });
 
+type CreateNewBeerCommentArgs = z.infer<typeof CreateNewBeerCommentServiceSchema>;
+
 const createNewBeerComment = async ({
   content,
   rating,
   beerPostId,
   userId,
-}: z.infer<typeof CreateNewBeerCommentServiceSchema>) => {
+}: CreateNewBeerCommentArgs): Promise<z.infer<typeof BeerCommentQueryResult>> => {
   return DBClient.instance.beerComment.create({
     data: {
       content,
@@ -26,6 +29,7 @@ const createNewBeerComment = async ({
       rating: true,
       postedBy: { select: { id: true, username: true } },
       createdAt: true,
+      updatedAt: true,
     },
   });
 };

src/services/BeerComment/editBeerCommentById.ts

@@ -1,4 +1,6 @@
 import DBClient from '@/prisma/DBClient';
+import { z } from 'zod';
+import BeerCommentQueryResult from './schema/BeerCommentQueryResult';
 
 interface EditBeerCommentByIdArgs {
   id: string;
@@ -6,17 +8,23 @@ interface EditBeerCommentByIdArgs {
   rating: number;
 }
 
-const editBeerCommentById = async ({ id, content, rating }: EditBeerCommentByIdArgs) => {
-  const updated = await DBClient.instance.beerComment.update({
+const editBeerCommentById = async ({
+  id,
+  content,
+  rating,
+}: EditBeerCommentByIdArgs): Promise<z.infer<typeof BeerCommentQueryResult>> => {
+  return DBClient.instance.beerComment.update({
     where: { id },
-    data: {
-      content,
-      rating,
-      updatedAt: new Date(),
+    data: { content, rating, updatedAt: new Date() },
+    select: {
+      id: true,
+      content: true,
+      rating: true,
+      createdAt: true,
+      updatedAt: true,
+      postedBy: { select: { id: true, username: true, createdAt: true } },
     },
   });
-
-  return updated;
 };
 
 export default editBeerCommentById;

src/services/BeerComment/findBeerCommentById.ts

@@ -1,11 +1,25 @@
 import DBClient from '@/prisma/DBClient';
+import { z } from 'zod';
+import BeerCommentQueryResult from './schema/BeerCommentQueryResult';
 
-const findBeerCommentById = async (id: string) => {
-  const comment = await DBClient.instance.beerComment.findUnique({
-    where: { id },
+interface FindBeerCommentArgs {
+  beerCommentId: string;
+}
+
+const findBeerCommentById = async ({
+  beerCommentId,
+}: FindBeerCommentArgs): Promise<z.infer<typeof BeerCommentQueryResult> | null> => {
+  return DBClient.instance.beerComment.findUnique({
+    where: { id: beerCommentId },
+    select: {
+      id: true,
+      content: true,
+      rating: true,
+      createdAt: true,
+      updatedAt: true,
+      postedBy: { select: { id: true, username: true, createdAt: true } },
+    },
   });
-
-  return comment;
 };
 
 export default findBeerCommentById;

src/services/BeerComment/getAllBeerComments.ts

@@ -1,28 +1,31 @@
 import DBClient from '@/prisma/DBClient';
-import BeerPostQueryResult from '@/services/BeerPost/schema/BeerPostQueryResult';
 import { z } from 'zod';
 import CommentQueryResult from '../schema/CommentSchema/CommentQueryResult';
 
-const getAllBeerComments = async (
-  { id }: Pick<z.infer<typeof BeerPostQueryResult>, 'id'>,
-  { pageSize, pageNum = 0 }: { pageSize: number; pageNum?: number },
-) => {
-  const skip = (pageNum - 1) * pageSize;
-  const beerComments: z.infer<typeof CommentQueryResult>[] =
-    await DBClient.instance.beerComment.findMany({
-      skip,
-      take: pageSize,
-      where: { beerPostId: id },
-      select: {
-        id: true,
-        content: true,
-        rating: true,
-        createdAt: true,
-        postedBy: { select: { id: true, username: true, createdAt: true } },
-      },
-      orderBy: { createdAt: 'desc' },
-    });
-  return beerComments;
+interface GetAllBeerCommentsArgs {
+  beerPostId: string;
+  pageNum: number;
+  pageSize: number;
+}
+
+const getAllBeerComments = async ({
+  beerPostId,
+  pageNum,
+  pageSize,
+}: GetAllBeerCommentsArgs): Promise<z.infer<typeof CommentQueryResult>[]> => {
+  return DBClient.instance.beerComment.findMany({
+    skip: (pageNum - 1) * pageSize,
+    take: pageSize,
+    where: { beerPostId },
+    orderBy: { createdAt: 'desc' },
+    select: {
+      id: true,
+      content: true,
+      rating: true,
+      createdAt: true,
+      postedBy: { select: { id: true, username: true, createdAt: true } },
+    },
+  });
 };
 
 export default getAllBeerComments;

src/services/BeerComment/getBeerCommentCount.ts

@@ -1,11 +1,13 @@
 import DBClient from '@/prisma/DBClient';
 
-const getBeerCommentCount = async (beerPostId: string) => {
-  const count = await DBClient.instance.beerComment.count({
-    where: { beerPostId },
-  });
+interface GetBeerCommentCountArgs {
+  beerPostId: string;
+}
 
-  return count;
+const getBeerCommentCount = async ({
+  beerPostId,
+}: GetBeerCommentCountArgs): Promise<number> => {
+  return DBClient.instance.beerComment.count({ where: { beerPostId } });
 };
 
 export default getBeerCommentCount;

src/services/BeerComment/schema/BeerCommentQueryResult.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+
+const BeerCommentQueryResult = z.object({
+  id: z.string().cuid(),
+  content: z.string(),
+  rating: z.number(),
+  postedBy: z.object({
+    id: z.string().cuid(),
+    username: z.string(),
+  }),
+  createdAt: z.coerce.date(),
+  updatedAt: z.coerce.date().nullable(),
+});
+
+export default BeerCommentQueryResult;

src/services/BeerComment/schema/CreateNewBeerCommentSchema.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+
+const CreateCommentValidationSchema = z.object({
+  userId: z.string().uuid(),
+  beerPostId: z.string().uuid(),
+});
+
+export default CreateCommentValidationSchema;

src/services/BeerImage/addBeerImageToDB.ts

@@ -19,6 +19,7 @@ const addBeerImageToDB = ({
   userId,
 }: ProcessImageDataArgs) => {
   const beerImagePromises: Promise<BeerImage>[] = [];
+
   files.forEach((file) => {
     beerImagePromises.push(
       DBClient.instance.beerImage.create({

src/services/BeerPost/editBeerPostById.ts

@@ -5,10 +5,6 @@ import EditBeerPostValidationSchema from './schema/EditBeerPostValidationSchema'
 const schema = EditBeerPostValidationSchema.omit({ id: true });
 
 export default async function editBeerPostById(id: string, data: z.infer<typeof schema>) {
-  const beerPost = await DBClient.instance.beerPost.update({
-    where: { id },
-    data,
-  });
-
+  const beerPost = await DBClient.instance.beerPost.update({ where: { id }, data });
   return beerPost;
 }

src/services/BeerPost/getBeerRecommendations.ts

@@ -16,6 +16,7 @@ const getBeerRecommendations = async ({
 }: GetBeerRecommendationsArgs) => {
   const skip = (pageNum - 1) * pageSize;
   const take = pageSize;
+
   const beerRecommendations: z.infer<typeof BeerPostQueryResult>[] =
     await DBClient.instance.beerPost.findMany({
       where: {

src/services/BeerPost/schema/BeerPostQueryResult.ts

@@ -13,6 +13,7 @@ const BeerPostQueryResult = z.object({
   style: z.object({ id: z.string(), name: z.string(), description: z.string() }),
   postedBy: z.object({ id: z.string(), username: z.string() }),
   createdAt: z.coerce.date(),
+  updatedAt: z.coerce.date().optional(),
 });
 
 export default BeerPostQueryResult;

src/services/BeerPostLike/createBeerPostLike.ts

@@ -2,19 +2,14 @@ import DBClient from '@/prisma/DBClient';
 import { z } from 'zod';
 import GetUserSchema from '../User/schema/GetUserSchema';
 
-const createBeerPostLike = async ({
-  id,
-  user,
-}: {
+interface CreateBeerPostLikeArgs {
   id: string;
   user: z.infer<typeof GetUserSchema>;
-}) => {
-  return DBClient.instance.beerPostLike.create({
-    data: {
-      beerPost: { connect: { id } },
-      likedBy: { connect: { id: user.id } },
-    },
+}
+
+const createBeerPostLike = async ({ id, user }: CreateBeerPostLikeArgs) =>
+  DBClient.instance.beerPostLike.create({
+    data: { beerPost: { connect: { id } }, likedBy: { connect: { id: user.id } } },
   });
-};
 
 export default createBeerPostLike;

src/services/BeerPostLike/getBeerPostLikeCount.ts

@@ -1,11 +1,6 @@
 import DBClient from '@/prisma/DBClient';
 
-const getBeerPostLikeCount = async (beerPostId: string) => {
-  const count = await DBClient.instance.beerPostLike.count({
-    where: { beerPostId },
-  });
-
-  return count;
-};
+const getBeerPostLikeCount = async ({ beerPostId }: { beerPostId: string }) =>
+  DBClient.instance.beerPostLike.count({ where: { beerPostId } });
 
 export default getBeerPostLikeCount;

src/services/BeerPostLike/removeBeerPostLikeById.ts

@@ -1,11 +1,10 @@
 import DBClient from '@/prisma/DBClient';
 
-const removeBeerPostLikeById = async (id: string) => {
-  return DBClient.instance.beerPostLike.delete({
-    where: {
-      id,
-    },
-  });
-};
+interface RemoveBeerPostLikeArgs {
+  beerLikeId: string;
+}
+
+const removeBeerPostLikeById = async ({ beerLikeId }: RemoveBeerPostLikeArgs) =>
+  DBClient.instance.beerPostLike.delete({ where: { id: beerLikeId } });
 
 export default removeBeerPostLikeById;

src/services/BeerStyles/getAllBeerStyles.ts

@@ -2,11 +2,14 @@ import DBClient from '@/prisma/DBClient';
 import { z } from 'zod';
 import BeerStyleQueryResult from './schema/BeerStyleQueryResult';
 
-const getAllBeerStyles = async (
-  pageNum: number,
-  pageSize: number,
-): Promise<z.infer<typeof BeerStyleQueryResult>[]> => {
-  const styles = (await DBClient.instance.beerStyle.findMany({
+const getAllBeerStyles = async ({
+  pageNum,
+  pageSize,
+}: {
+  pageNum: number;
+  pageSize: number;
+}): Promise<z.infer<typeof BeerStyleQueryResult>[]> =>
+  DBClient.instance.beerStyle.findMany({
     take: pageSize,
     skip: (pageNum - 1) * pageSize,
     select: {
@@ -20,9 +23,6 @@ const getAllBeerStyles = async (
       description: true,
       glassware: { select: { id: true, name: true } },
     },
-  })) as z.infer<typeof BeerStyleQueryResult>[];
-
-  return styles;
-};
+  }) as ReturnType<typeof getAllBeerStyles>;
 
 export default getAllBeerStyles;

src/services/schema/PaginatedQueryResponseSchema.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+
+const PaginatedQueryResponseSchema = z.object({
+  page_num: z.string(),
+  page_size: z.string(),
+});
+
+export default PaginatedQueryResponseSchema;