Restructure codebase to use src directory

src/services/BeerPost/createNewBeerPost.ts

@@ -0,0 +1,46 @@
+import DBClient from '@/prisma/DBClient';
+import { z } from 'zod';
+import beerPostQueryResult from './schema/BeerPostQueryResult';
+import CreateBeerPostValidationSchema from './schema/CreateBeerPostValidationSchema';
+
+const CreateBeerPostWithUserSchema = CreateBeerPostValidationSchema.extend({
+  userId: z.string().uuid(),
+});
+
+const createNewBeerPost = async ({
+  name,
+  description,
+  abv,
+  ibu,
+  typeId,
+  breweryId,
+  userId,
+}: z.infer<typeof CreateBeerPostWithUserSchema>) => {
+  const newBeerPost: z.infer<typeof beerPostQueryResult> =
+    await DBClient.instance.beerPost.create({
+      data: {
+        name,
+        description,
+        abv,
+        ibu,
+        type: { connect: { id: typeId } },
+        postedBy: { connect: { id: userId } },
+        brewery: { connect: { id: breweryId } },
+      },
+      select: {
+        id: true,
+        name: true,
+        description: true,
+        abv: true,
+        ibu: true,
+        createdAt: true,
+        beerImages: { select: { id: true, path: true, caption: true, alt: true } },
+        brewery: { select: { id: true, name: true } },
+        type: { select: { id: true, name: true } },
+        postedBy: { select: { id: true, username: true } },
+      },
+    });
+  return newBeerPost;
+};
+
+export default createNewBeerPost;

src/services/BeerPost/editBeerPostById.ts

@@ -0,0 +1,14 @@
+import DBClient from '@/prisma/DBClient';
+import { z } from 'zod';
+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,
+  });
+
+  return beerPost;
+}

src/services/BeerPost/getAllBeerPosts.ts

@@ -0,0 +1,32 @@
+import DBClient from '@/prisma/DBClient';
+import beerPostQueryResult from '@/services/BeerPost/schema/BeerPostQueryResult';
+import { z } from 'zod';
+
+const prisma = DBClient.instance;
+
+const getAllBeerPosts = async (pageNum: number, pageSize: number) => {
+  const skip = (pageNum - 1) * pageSize;
+
+  const beerPosts: z.infer<typeof beerPostQueryResult>[] = await prisma.beerPost.findMany(
+    {
+      select: {
+        id: true,
+        name: true,
+        ibu: true,
+        abv: true,
+        description: true,
+        createdAt: true,
+        type: { select: { name: true, id: true } },
+        brewery: { select: { name: true, id: true } },
+        postedBy: { select: { id: true, username: true } },
+        beerImages: { select: { path: true, caption: true, id: true, alt: true } },
+      },
+      take: pageSize,
+      skip,
+    },
+  );
+
+  return beerPosts;
+};
+
+export default getAllBeerPosts;

src/services/BeerPost/getBeerPostById.ts

@@ -0,0 +1,28 @@
+import DBClient from '@/prisma/DBClient';
+import beerPostQueryResult from '@/services/BeerPost/schema/BeerPostQueryResult';
+import { z } from 'zod';
+
+const prisma = DBClient.instance;
+
+const getBeerPostById = async (id: string) => {
+  const beerPost: z.infer<typeof beerPostQueryResult> | null =
+    await prisma.beerPost.findFirst({
+      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: { id },
+    });
+
+  return beerPost;
+};
+
+export default getBeerPostById;

src/services/BeerPost/getBeerRecommendations.ts

@@ -0,0 +1,22 @@
+import DBClient from '@/prisma/DBClient';
+import beerPostQueryResult from '@/services/BeerPost/schema/BeerPostQueryResult';
+import { z } from 'zod';
+
+const getBeerRecommendations = async (
+  beerPost: Pick<z.infer<typeof beerPostQueryResult>, 'type' | 'brewery' | 'id'>,
+) => {
+  const beerRecommendations = await DBClient.instance.beerPost.findMany({
+    where: {
+      OR: [{ typeId: beerPost.type.id }, { breweryId: beerPost.brewery.id }],
+      NOT: { id: beerPost.id },
+    },
+    include: {
+      beerImages: { select: { id: true, path: true, caption: true, alt: true } },
+      brewery: { select: { id: true, name: true } },
+    },
+  });
+
+  return beerRecommendations;
+};
+
+export default getBeerRecommendations;

src/services/BeerPost/schema/BeerPostQueryResult.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+
+const beerPostQueryResult = z.object({
+  id: z.string(),
+  name: z.string(),
+  brewery: z.object({ id: z.string(), name: z.string() }),
+  description: z.string(),
+  beerImages: z.array(
+    z.object({ path: z.string(), caption: z.string(), id: z.string(), alt: z.string() }),
+  ),
+  ibu: z.number(),
+  abv: z.number(),
+  type: z.object({ id: z.string(), name: z.string() }),
+  postedBy: z.object({ id: z.string(), username: z.string() }),
+  createdAt: z.coerce.date(),
+});
+
+export default beerPostQueryResult;

src/services/BeerPost/schema/BeerRecommendationQueryResult.ts

@@ -0,0 +1,15 @@
+import { BeerPost } from '@prisma/client';
+
+type BeerRecommendationQueryResult = BeerPost & {
+  brewery: {
+    id: string;
+    name: string;
+  };
+  beerImages: {
+    id: string;
+    alt: string;
+    url: string;
+  }[];
+};
+
+export default BeerRecommendationQueryResult;

src/services/BeerPost/schema/CreateBeerPostValidationSchema.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+
+const CreateBeerPostValidationSchema = 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 CreateBeerPostValidationSchema;

src/services/BeerPost/schema/EditBeerPostValidationSchema.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import CreateBeerPostValidationSchema from './CreateBeerPostValidationSchema';
+
+const EditBeerPostValidationSchema = CreateBeerPostValidationSchema.omit({
+  breweryId: true,
+  typeId: true,
+}).extend({ id: z.string().uuid() });
+
+export default EditBeerPostValidationSchema;