Refactored api services into sep files. Client fix

Fixed hydration errors in beers/[id] by implementing timeDistanceState

services/BeerComment/createNewBeerComment.ts

@@ -0,0 +1,28 @@
+import DBClient from '@/prisma/DBClient';
+import { z } from 'zod';
+import BeerCommentValidationSchema from './schema/CreateBeerCommentValidationSchema';
+
+const createNewBeerComment = async ({
+  content,
+  rating,
+  beerPostId,
+}: z.infer<typeof BeerCommentValidationSchema>) => {
+  const user = await DBClient.instance.user.findFirstOrThrow();
+  return DBClient.instance.beerComment.create({
+    data: {
+      content,
+      rating,
+      beerPost: { connect: { id: beerPostId } },
+      postedBy: { connect: { id: user.id } },
+    },
+    select: {
+      id: true,
+      content: true,
+      rating: true,
+      postedBy: { select: { id: true, username: true } },
+      createdAt: true,
+    },
+  });
+};
+
+export default createNewBeerComment;

services/BeerComment/getAllBeerComments.ts

@@ -1,13 +1,13 @@
-import BeerCommentQueryResult from '@/services/BeerPost/types/BeerCommentQueryResult';
 import DBClient from '@/prisma/DBClient';
-import BeerPostQueryResult from './types/BeerPostQueryResult';
+import BeerPostQueryResult from '../BeerPost/schema/BeerPostQueryResult';
+import { BeerCommentQueryResultArrayT } from './schema/BeerCommentQueryResult';
 
 const getAllBeerComments = async (
   { id }: Pick<BeerPostQueryResult, 'id'>,
   { pageSize, pageNum = 0 }: { pageSize: number; pageNum?: number },
 ) => {
   const skip = (pageNum - 1) * pageSize;
-  const beerComments: BeerCommentQueryResult[] =
+  const beerComments: BeerCommentQueryResultArrayT =
     await DBClient.instance.beerComment.findMany({
       where: {
         beerPostId: id,

services/BeerComment/schema/BeerCommentQueryResult.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+
+export const BeerCommentQueryResult = z.object({
+  id: z.string().uuid(),
+  content: z.string().min(1).max(300),
+  rating: z.number().int().min(1).max(5),
+  createdAt: z.date().or(z.string().datetime()),
+  postedBy: z.object({
+    id: z.string().uuid(),
+    username: z.string().min(1).max(50),
+  }),
+});
+export const BeerCommentQueryResultArray = z.array(BeerCommentQueryResult);
+export type BeerCommentQueryResultT = z.infer<typeof BeerCommentQueryResult>;
+export type BeerCommentQueryResultArrayT = z.infer<typeof BeerCommentQueryResultArray>;

services/BeerComment/schema/CreateBeerCommentValidationSchema.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+
+const BeerCommentValidationSchema = z.object({
+  content: z
+    .string()
+    .min(1, {
+      message: 'Comment must not be empty.',
+    })
+    .max(300, {
+      message: 'Comment must be less than 300 characters.',
+    }),
+  rating: z
+    .number()
+    .int()
+    .min(1, { message: 'Rating must be greater than 1.' })
+    .max(5, { message: 'Rating must be less than 5.' }),
+  beerPostId: z.string().uuid({
+    message: 'Beer post ID must be a valid UUID.',
+  }),
+});
+
+export default BeerCommentValidationSchema;

services/BeerPost/createNewBeerPost.ts

@@ -0,0 +1,29 @@
+import DBClient from '@/prisma/DBClient';
+import { z } from 'zod';
+import BeerPostValidationSchema from './schema/CreateBeerPostValidationSchema';
+
+const createNewBeerPost = async ({
+  name,
+  description,
+  abv,
+  ibu,
+  typeId,
+  breweryId,
+}: z.infer<typeof BeerPostValidationSchema>) => {
+  const user = await DBClient.instance.user.findFirstOrThrow();
+
+  const newBeerPost = await DBClient.instance.beerPost.create({
+    data: {
+      name,
+      description,
+      abv,
+      ibu,
+      type: { connect: { id: typeId } },
+      postedBy: { connect: { id: user.id } },
+      brewery: { connect: { id: breweryId } },
+    },
+  });
+  return newBeerPost;
+};
+
+export default createNewBeerPost;

services/BeerPost/getAllBeerPosts.ts

@@ -1,5 +1,5 @@
 import DBClient from '@/prisma/DBClient';
-import BeerPostQueryResult from './types/BeerPostQueryResult';
+import BeerPostQueryResult from './schema/BeerPostQueryResult';
 
 const prisma = DBClient.instance;
 

services/BeerPost/getBeerPostById.ts

@@ -1,5 +1,5 @@
 import DBClient from '@/prisma/DBClient';
-import BeerPostQueryResult from './types/BeerPostQueryResult';
+import BeerPostQueryResult from './schema/BeerPostQueryResult';
 
 const prisma = DBClient.instance;
 

services/BeerPost/getBeerRecommendations.ts

@@ -1,27 +1,17 @@
-import BeerPostQueryResult from '@/services/BeerPost/types/BeerPostQueryResult';
 import DBClient from '@/prisma/DBClient';
+import BeerPostQueryResult from './schema/BeerPostQueryResult';
 
 const getBeerRecommendations = async (
-  beerPost: Pick<BeerPostQueryResult, 'type' | 'brewery'>,
+  beerPost: Pick<BeerPostQueryResult, 'type' | 'brewery' | 'id'>,
 ) => {
   const beerRecommendations = await DBClient.instance.beerPost.findMany({
     where: {
-      OR: [
-        {
-          typeId: beerPost.type.id,
-        },
-        {
-          breweryId: beerPost.brewery.id,
-        },
-      ],
+      OR: [{ typeId: beerPost.type.id }, { breweryId: beerPost.brewery.id }],
+      NOT: { id: beerPost.id },
     },
     include: {
-      beerImages: {
-        select: { id: true, url: true, alt: true },
-      },
-      brewery: {
-        select: { id: true, name: true },
-      },
+      beerImages: { select: { id: true, url: true, alt: true } },
+      brewery: { select: { id: true, name: true } },
     },
   });
 

services/BeerPost/schema/CreateBeerPostValidationSchema.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+
+const BeerPostValidationSchema = z.object({
+  name: z
+    .string({
+      required_error: 'Beer name is required.',
+      invalid_type_error: 'Beer name must be a string.',
+    })
+    .min(1, { message: 'Beer name is required.' })
+    .max(100, { message: 'Beer name is too long.' }),
+  description: z
+    .string()
+    .min(1, { message: 'Description is required.' })
+    .max(500, { message: 'Description is too long.' }),
+  abv: z
+    .number({
+      required_error: 'ABV is required.',
+      invalid_type_error: 'ABV must be a number.',
+    })
+    .min(0.1, { message: 'ABV must be greater than 0.1.' })
+    .max(50, { message: 'ABV must be less than 50.' }),
+  ibu: z
+    .number({
+      required_error: 'IBU is required.',
+      invalid_type_error: 'IBU must be a number.',
+    })
+    .min(2, { message: 'IBU must be greater than 2.' })
+    .max(100, { message: 'IBU must be less than 100.' }),
+  typeId: z
+    .string({
+      required_error: 'Type id is required.',
+      invalid_type_error: 'Type id must be a string.',
+    })
+    .uuid({ message: 'Invalid type id.' }),
+  breweryId: z
+    .string({
+      required_error: 'Brewery id is required.',
+      invalid_type_error: 'Brewery id must be a string.',
+    })
+    .uuid({ message: 'Invalid brewery id.' }),
+});
+
+export default BeerPostValidationSchema;

services/BeerPost/types/BeerCommentQueryResult.ts

@@ -1,13 +0,0 @@
-interface BeerCommentQueryResult {
-  id: string;
-  content: string;
-  rating: number;
-  createdAt: Date;
-  postedBy: {
-    id: string;
-    createdAt: Date;
-    username: string;
-  };
-}
-
-export default BeerCommentQueryResult;