Move next js project to archive (#207)

archive/next-js-web-app/src/services/posts/brewery-post/index.ts

@@ -0,0 +1,241 @@
+import DBClient from '@/prisma/DBClient';
+
+import {
+  CreateBreweryPostLocation,
+  CreateNewBreweryPost,
+  GetAllBreweryPosts,
+  GetAllBreweryPostsByPostedById,
+  GetBreweryPostById,
+  GetMapBreweryPosts,
+  UpdateBreweryPost,
+} from './types';
+
+/**
+ * The select object to use when querying for brewery posts.
+ *
+ * @remarks
+ *   Prisma does not support tuples, so we have to typecast the coordinates field to
+ *   [number, number] in order to satisfy the zod schema.
+ */
+const breweryPostSelect = {
+  id: true,
+  name: true,
+  description: true,
+  createdAt: true,
+  dateEstablished: true,
+  postedBy: { select: { id: true, username: true } },
+  breweryImages: {
+    select: {
+      path: true,
+      caption: true,
+      id: true,
+      alt: true,
+      createdAt: true,
+      updatedAt: true,
+    },
+  },
+  location: {
+    select: {
+      city: true,
+      address: true,
+      coordinates: true,
+      country: true,
+      stateOrProvince: true,
+    },
+  },
+} as const;
+
+/**
+ * Creates a new brewery post.
+ *
+ * @param args - The arguments to create a new brewery post.
+ * @param args.name - The name of the brewery.
+ * @param args.description - The description of the brewery.
+ * @param args.dateEstablished - The date the brewery was established.
+ * @param args.userId - The id of the user who created the brewery post.
+ * @param args.locationId - The id of the location of the brewery.
+ * @returns The newly created brewery post.
+ */
+export const createNewBreweryPostService: CreateNewBreweryPost = async ({
+  dateEstablished,
+  description,
+  locationId,
+  name,
+  userId,
+}) => {
+  const post = (await DBClient.instance.breweryPost.create({
+    data: {
+      name,
+      description,
+      dateEstablished,
+      location: { connect: { id: locationId } },
+      postedBy: { connect: { id: userId } },
+    },
+    select: breweryPostSelect,
+  })) as Awaited<ReturnType<typeof createNewBreweryPostService>>;
+
+  return post;
+};
+
+/**
+ * Retrieves all brewery posts paginated.
+ *
+ * @param args - The arguments to get all brewery posts.
+ * @param args.pageNum - The page number of the brewery posts to get.
+ * @param args.pageSize - The number of brewery posts to get per page.
+ * @returns All brewery posts.
+ */
+export const getAllBreweryPostsService: GetAllBreweryPosts = async ({
+  pageNum,
+  pageSize,
+}) => {
+  const breweryPosts = (await DBClient.instance.breweryPost.findMany({
+    take: pageSize,
+    skip: (pageNum - 1) * pageSize,
+    select: breweryPostSelect,
+    orderBy: { createdAt: 'desc' },
+  })) as Awaited<ReturnType<typeof getAllBreweryPostsService>>['breweryPosts'];
+
+  const count = await DBClient.instance.breweryPost.count();
+  return { breweryPosts, count };
+};
+
+/**
+ * Retrieves a brewery post by ID.
+ *
+ * @param args - The arguments to get a brewery post by ID.
+ * @param args.breweryPostId - The ID of the brewery post to get.
+ * @returns The brewery post.
+ */
+export const getBreweryPostByIdService: GetBreweryPostById = async ({
+  breweryPostId,
+}) => {
+  const breweryPost = await DBClient.instance.breweryPost.findFirst({
+    select: breweryPostSelect,
+    where: { id: breweryPostId },
+  });
+
+  return breweryPost as Awaited<ReturnType<typeof getBreweryPostByIdService>>;
+};
+
+/**
+ * Retrieves all brewery posts by posted by ID.
+ *
+ * @param args - The arguments to get all brewery posts by posted by ID.
+ * @param args.pageNum - The page number of the brewery posts to get.
+ * @param args.pageSize - The number of brewery posts to get per page.
+ * @param args.postedById - The ID of the user who posted the brewery posts.
+ */
+export const getAllBreweryPostsByPostedByIdService: GetAllBreweryPostsByPostedById =
+  async ({ pageNum, pageSize, postedById }) => {
+    const breweryPosts = (await DBClient.instance.breweryPost.findMany({
+      where: { postedBy: { id: postedById } },
+      take: pageSize,
+      skip: (pageNum - 1) * pageSize,
+      select: breweryPostSelect,
+      orderBy: { createdAt: 'desc' },
+    })) as Awaited<
+      ReturnType<typeof getAllBreweryPostsByPostedByIdService>
+    >['breweryPosts'];
+
+    const count = await DBClient.instance.breweryPost.count({
+      where: { postedBy: { id: postedById } },
+    });
+
+    return { breweryPosts, count };
+  };
+
+/**
+ * Creates a brewery post location.
+ *
+ * @param args - The arguments to create a brewery post location.
+ * @param args.body - The body of the request.
+ * @param args.body.address - The address of the brewery.
+ * @param args.body.city - The city of the brewery.
+ * @param args.body.country - The country of the brewery.
+ * @param args.body.stateOrProvince - The state or province of the brewery.
+ * @param args.body.coordinates - The coordinates of the brewery in an array of [latitude,
+ *   longitude].
+ * @param args.postedById - The ID of the user who posted the brewery post.
+ * @returns The newly created brewery post location.
+ */
+export const createBreweryPostLocationService: CreateBreweryPostLocation = async ({
+  body: { address, city, country, stateOrProvince, coordinates },
+  postedById,
+}) => {
+  const [latitude, longitude] = coordinates;
+
+  return DBClient.instance.breweryLocation.create({
+    data: {
+      address,
+      city,
+      country,
+      stateOrProvince,
+      coordinates: [latitude, longitude],
+      postedBy: { connect: { id: postedById } },
+    },
+    select: { id: true },
+  });
+};
+
+/**
+ * Gets all brewery posts for the post map.
+ *
+ * @param args - The arguments to get all brewery posts for the post map.
+ * @param args.pageNum - The page number of the brewery posts to get.
+ * @param args.pageSize - The number of brewery posts to get per page.
+ * @returns All brewery posts for the post map.
+ */
+export const getMapBreweryPostsService: GetMapBreweryPosts = async ({
+  pageNum,
+  pageSize,
+}) => {
+  const breweryPosts = await DBClient.instance.breweryPost.findMany({
+    take: pageSize,
+    skip: (pageNum - 1) * pageSize,
+    select: {
+      id: true,
+      name: true,
+      location: {
+        select: { coordinates: true, city: true, country: true, stateOrProvince: true },
+      },
+    },
+    orderBy: { createdAt: 'desc' },
+  });
+
+  const count = await DBClient.instance.breweryPost.count();
+  return { breweryPosts, count };
+};
+
+/**
+ * Updates a brewery post.
+ *
+ * @param args - The arguments to update a brewery post.
+ * @param args.breweryPostId - The ID of the brewery post to update.
+ * @param args.body - The body of the request.
+ * @param args.body.name - The name of the brewery.
+ * @param args.body.description - The description of the brewery.
+ * @param args.body.dateEstablished - The date the brewery was established.
+ * @returns The updated brewery post.
+ */
+export const updateBreweryPostService: UpdateBreweryPost = async ({
+  breweryPostId,
+  body,
+}) => {
+  const breweryPost = await DBClient.instance.breweryPost.update({
+    where: { id: breweryPostId },
+    data: body,
+    select: breweryPostSelect,
+  });
+
+  return breweryPost as Awaited<ReturnType<typeof updateBreweryPostService>>;
+};
+
+export const deleteBreweryPostService: GetBreweryPostById = async ({ breweryPostId }) => {
+  const breweryPost = await DBClient.instance.breweryPost.delete({
+    where: { id: breweryPostId },
+    select: breweryPostSelect,
+  });
+
+  return breweryPost as Awaited<ReturnType<typeof deleteBreweryPostService>>;
+};

archive/next-js-web-app/src/services/posts/brewery-post/schema/BreweryPostMapQueryResult.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+
+const BreweryPostMapQueryResult = z.object({
+  location: z.object({
+    coordinates: z.array(z.number()),
+    city: z.string(),
+    country: z.string().nullable(),
+    stateOrProvince: z.string().nullable(),
+  }),
+  id: z.string(),
+  name: z.string(),
+});
+
+export default BreweryPostMapQueryResult;

archive/next-js-web-app/src/services/posts/brewery-post/schema/BreweryPostQueryResult.ts

@@ -0,0 +1,21 @@
+import ImageQueryValidationSchema from '@/services/schema/ImageSchema/ImageQueryValidationSchema';
+import { z } from 'zod';
+
+const BreweryPostQueryResult = z.object({
+  id: z.string(),
+  name: z.string(),
+  description: z.string(),
+  location: z.object({
+    city: z.string(),
+    address: z.string(),
+    coordinates: z.tuple([z.number(), z.number()]),
+    country: z.string().nullable(),
+    stateOrProvince: z.string().nullable(),
+  }),
+  postedBy: z.object({ id: z.string(), username: z.string() }),
+  breweryImages: z.array(ImageQueryValidationSchema),
+  createdAt: z.coerce.date(),
+  dateEstablished: z.coerce.date(),
+});
+
+export default BreweryPostQueryResult;

archive/next-js-web-app/src/services/posts/brewery-post/schema/CreateBreweryPostSchema.ts

@@ -0,0 +1,55 @@
+import { isPast } from 'date-fns';
+import { z } from 'zod';
+
+const CreateBreweryPostSchema = z.object({
+  name: z
+    .string({
+      required_error: 'Brewery name is required.',
+      invalid_type_error: 'Brewery name must be a string.',
+    })
+    .min(1, { message: 'Brewery name is required.' })
+    .max(100, { message: 'Brewery name is too long.' }),
+  description: z
+    .string({
+      required_error: 'Description is required.',
+      invalid_type_error: 'Description must be a string.',
+    })
+    .min(1, { message: 'Description is required.' })
+    .max(1500, { message: 'Description is too long.' }),
+  address: z
+    .string({
+      required_error: 'Address is required.',
+      invalid_type_error: 'Address must be a string.',
+    })
+    .min(1, { message: 'Address is required.' })
+    .max(300, { message: 'Address is too long.' }),
+
+  city: z
+    .string({
+      required_error: 'City is required.',
+      invalid_type_error: 'City must be a string.',
+    })
+    .min(1, { message: 'City is required.' })
+    .max(100, { message: 'City is too long.' }),
+
+  region: z
+    .string({ invalid_type_error: 'region must be a string.' })
+    .min(1, { message: 'region is required.' })
+    .max(100, { message: 'region is too long.' })
+    .optional(),
+
+  country: z
+    .string({ invalid_type_error: 'Country must be a string.' })
+    .max(100, { message: 'Country is too long.' })
+    .optional(),
+
+  dateEstablished: z.coerce
+    .date({
+      required_error: 'Date established is required.',
+      invalid_type_error: 'Date established must be a date string.',
+    })
+    .refine((val) => !Number.isNaN(val.toString()), { message: 'Date is invalid.' })
+    .refine((val) => isPast(new Date(val)), { message: 'Date must be in the past.' }),
+});
+
+export default CreateBreweryPostSchema;

archive/next-js-web-app/src/services/posts/brewery-post/schema/CreateNewBreweryPostWithoutLocationSchema.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import CreateBreweryPostSchema from './CreateBreweryPostSchema';
+
+const CreateNewBreweryPostWithoutLocationSchema = CreateBreweryPostSchema.omit({
+  address: true,
+  city: true,
+  country: true,
+  stateOrProvince: true,
+}).extend({
+  userId: z.string().cuid(),
+  locationId: z.string().cuid(),
+});
+
+export default CreateNewBreweryPostWithoutLocationSchema;

archive/next-js-web-app/src/services/posts/brewery-post/schema/EditBreweryPostValidationSchema.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import CreateBreweryPostSchema from './CreateBreweryPostSchema';
+
+const EditBreweryPostValidationSchema = CreateBreweryPostSchema.extend({
+  id: z.string().cuid(),
+}).omit({
+  address: true,
+  city: true,
+  region: true,
+  country: true,
+});
+
+export default EditBreweryPostValidationSchema;

archive/next-js-web-app/src/services/posts/brewery-post/schema/GetMapBreweryPostsSchema.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+
+const GetMapBreweryPostsSchema = z.object({
+  name: z.string(),
+  id: z.string().cuid(),
+  location: z.object({
+    city: z.string(),
+    country: z.string().nullable(),
+    stateOrProvince: z.string().nullable(),
+    coordinates: z.array(z.number(), z.number()),
+  }),
+});
+
+export default GetMapBreweryPostsSchema;

archive/next-js-web-app/src/services/posts/brewery-post/types/index.ts

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+import BreweryPostQueryResult from '../schema/BreweryPostQueryResult';
+import CreateNewBreweryPostWithoutLocationSchema from '../schema/CreateNewBreweryPostWithoutLocationSchema';
+import BreweryPostMapQueryResult from '../schema/BreweryPostMapQueryResult';
+
+export type CreateNewBreweryPost = (
+  args: z.infer<typeof CreateNewBreweryPostWithoutLocationSchema>,
+) => Promise<z.infer<typeof BreweryPostQueryResult>>;
+
+export type GetAllBreweryPosts = (args: {
+  pageNum: number;
+  pageSize: number;
+}) => Promise<{
+  breweryPosts: z.infer<typeof BreweryPostQueryResult>[];
+  count: number;
+}>;
+
+export type GetBreweryPostById = (args: {
+  breweryPostId: string;
+}) => Promise<z.infer<typeof BreweryPostQueryResult> | null>;
+
+export type GetAllBreweryPostsByPostedById = (args: {
+  pageNum: number;
+  pageSize: number;
+  postedById: string;
+}) => Promise<{
+  breweryPosts: z.infer<typeof BreweryPostQueryResult>[];
+  count: number;
+}>;
+
+export type CreateBreweryPostLocation = (args: {
+  body: {
+    address: string;
+    city: string;
+    country?: string;
+    stateOrProvince?: string;
+    coordinates: [number, number];
+  };
+  postedById: string;
+}) => Promise<{ id: string }>;
+
+export type GetMapBreweryPosts = (args: {
+  pageNum: number;
+  pageSize: number;
+}) => Promise<{
+  breweryPosts: z.infer<typeof BreweryPostMapQueryResult>[];
+  count: number;
+}>;
+
+export type UpdateBreweryPost = (args: {
+  breweryPostId: string;
+  body: {
+    name: string;
+    description: string;
+    dateEstablished: Date;
+  };
+}) => Promise<z.infer<typeof BreweryPostQueryResult>>;