Antti | api/user

pages/api/users/[uuid].ts

@@ -0,0 +1,115 @@
+import { User } from '~/shared/types';
+import { NextApiRequest, NextApiResponse } from 'next';
+import prisma from '~/prisma';
+import { errorFound } from '.';
+
+type HandlerParams<ResponseType = unknown> = {
+  req: NextApiRequest;
+  res: NextApiResponse<ResponseType>;
+  queryUUID: string;
+};
+
+const HANDLERS: Record<string, (params: HandlerParams) => Promise<void>> = {
+  GET: handleGET,
+  PATCH: handlePATCH,
+  PUT: handlePUT,
+  DELETE: handleDELETE,
+};
+
+export default async function handlePrisma(
+  req: NextApiRequest,
+  res: NextApiResponse,
+) {
+  try {
+    const reqHandler = req.method !== undefined && HANDLERS[req.method];
+    if (reqHandler) {
+      if (typeof req.query.uuid !== 'string') {
+        throw new Error('Invalid ID', { cause: 'idError' });
+      }
+      const queryUUID = req.query.uuid;
+      await reqHandler({ req, res, queryUUID });
+    } else {
+      return res
+        .status(405)
+        .send(
+          `${req.method} is not a valid method. GET, PATCH, PUT and DELETE request are valid.`,
+        );
+    }
+  } catch (e) {
+    return errorFound(res, e);
+  }
+}
+
+async function handleGET({ res, queryUUID }: HandlerParams<User>) {
+  const user = await prisma.user.findUniqueOrThrow({
+    where: {
+      uuid: queryUUID,
+    },
+    select: {
+      uuid: true,
+      firstName: true,
+      lastName: true,
+      email: true,
+      createdAt: true,
+      updatedAt: true,
+    },
+  });
+  return res.status(200).json(user);
+}
+
+async function handlePATCH({ req, res, queryUUID }: HandlerParams<User>) {
+  const newUserDetails = req.body as User;
+
+  const updatedUser = await prisma.user.update({
+    where: {
+      uuid: queryUUID,
+    },
+    data: {
+      email: newUserDetails.email,
+      firstName: newUserDetails.firstName,
+      lastName: newUserDetails.lastName,
+    },
+    select: {
+      uuid: true,
+      firstName: true,
+      lastName: true,
+      email: true,
+      createdAt: true,
+      updatedAt: true,
+    },
+  });
+
+  return res.status(200).json(updatedUser);
+}
+
+async function handlePUT({ req, res, queryUUID }: HandlerParams<User>) {
+  const newUserDetails = req.body as User;
+
+  const updatedUser = await prisma.user.update({
+    where: {
+      uuid: queryUUID,
+    },
+    data: newUserDetails,
+    select: {
+      uuid: true,
+      firstName: true,
+      lastName: true,
+      email: true,
+      createdAt: true,
+      updatedAt: true,
+    },
+  });
+
+  return res.status(200).json(updatedUser);
+}
+
+async function handleDELETE({ res, queryUUID }: HandlerParams) {
+  await prisma.user.delete({
+    where: {
+      uuid: queryUUID,
+    },
+  });
+
+  res.status(200).end();
+  return;
+}

pages/api/users/index.ts

@@ -0,0 +1,112 @@
+import { NextApiRequest, NextApiResponse } from 'next';
+import { CreateUser, User } from '~/shared/types';
+import prisma from '~/prisma';
+
+const HANDLER: Record<
+  string,
+  (req: NextApiRequest, res: NextApiResponse) => Promise<void>
+> = {
+  GET: handleGET,
+  POST: handlePOST,
+};
+
+export default async function handlePrisma(
+  req: NextApiRequest,
+  res: NextApiResponse,
+) {
+  try {
+    const reqHandler = req.method !== undefined && HANDLER[req.method];
+    if (reqHandler) {
+      await reqHandler(req, res);
+    } else {
+      return res
+        .status(405)
+        .send(
+          `${req.method} is not a valid method. Only GET and POST requests are valid!`,
+        );
+    }
+  } catch (e) {
+    return errorFound(res, e);
+  }
+}
+
+async function handleGET(req: NextApiRequest, res: NextApiResponse<User[]>) {
+  const users = await prisma.user.findMany({
+    select: {
+      uuid: true,
+      firstName: true,
+      lastName: true,
+      email: true,
+      createdAt: true,
+      updatedAt: true,
+    },
+  });
+
+  return res.status(200).json(users);
+}
+
+async function handlePOST(req: NextApiRequest, res: NextApiResponse<User>) {
+  const userDetails = req.body as CreateUser;
+  await isEmailValid(userDetails.email);
+
+  const addedUser = await prisma.user.create({
+    data: {
+      email: userDetails.email,
+      firstName: userDetails.firstName,
+      lastName: userDetails.lastName,
+      password: userDetails.password,
+    },
+    select: {
+      uuid: true,
+      firstName: true,
+      lastName: true,
+      email: true,
+      createdAt: true,
+      updatedAt: true,
+    },
+  });
+
+  return res.status(200).json(addedUser);
+}
+
+export function errorFound(res: NextApiResponse, e: unknown) {
+  if (e instanceof Error) {
+    if (e.message.toLowerCase() === 'no gift found') {
+      return res.status(400).send('Gift was not found!');
+    }
+    if (e.message === 'Invalid email!') {
+      return res.status(400).send(e.message);
+    }
+    if (e.message === 'Email is used already!') {
+      return res.status(400).send(e.message);
+    }
+    if (e.cause === 'idError') return res.status(400).send('Invalid ID!');
+    return res.status(500).send('Server error!');
+  }
+
+  return res.status(500).send('Unexpected error occurred!');
+}
+
+async function isEmailValid(emailAddress: string): Promise<boolean> {
+  const checkedEmailAddress = emailAddress
+    .toLowerCase()
+    .match(/^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/);
+  if (checkedEmailAddress === null) {
+    throw new Error('Invalid email!');
+  }
+
+  // checking if email exists in database
+  const isEmailFound = await prisma.user.findUnique({
+    where: {
+      email: emailAddress,
+    },
+  });
+
+  // email exists already
+  if (isEmailFound) {
+    throw new Error('Email is used already!');
+  }
+
+  // email is ready to be used
+  return true;
+}

shared/types.ts

@@ -1,7 +1,13 @@
-import { Prisma, Gift as PrismaGift } from '@prisma/client';
+import { Prisma, Gift as PrismaGift, User as PrismaUser } from '@prisma/client';
 
 export type Gift = Omit<PrismaGift, 'id' | 'userUUID'>;
 export type CreateGift = Omit<
   Prisma.GiftCreateInput,
-  'uuid' | 'createdAt' | 'updatedAt'
+  'uuid' | 'createdAt' | 'updatedAt' | 'user'
+>;
+
+export type User = Omit<PrismaUser, 'id' | 'password'>;
+export type CreateUser = Omit<
+  Prisma.UserCreateInput,
+  'uuid' | 'createdAt' | 'updatedAt' | 'gift'
 >;