fix case issue that caused rename prob

services/User/createNewUser.ts

@@ -0,0 +1,39 @@
+import { hashPassword } from '@/config/auth/passwordFns';
+import DBClient from '@/prisma/DBClient';
+import { z } from 'zod';
+import CreateUserValidationSchema from './schema/CreateUserValidationSchema';
+import GetUserSchema from './schema/GetUserSchema';
+
+const createNewUser = async ({
+  email,
+  password,
+  firstName,
+  lastName,
+  dateOfBirth,
+  username,
+}: z.infer<typeof CreateUserValidationSchema>) => {
+  const hash = await hashPassword(password);
+  const user: z.infer<typeof GetUserSchema> = await DBClient.instance.user.create({
+    data: {
+      username,
+      email,
+      hash,
+      firstName,
+      lastName,
+      dateOfBirth: new Date(dateOfBirth),
+    },
+    select: {
+      id: true,
+      username: true,
+      email: true,
+      firstName: true,
+      lastName: true,
+      dateOfBirth: true,
+      createdAt: true,
+    },
+  });
+
+  return user;
+};
+
+export default createNewUser;

services/User/findUserByEmail.ts

@@ -0,0 +1,13 @@
+import DBClient from '@/prisma/DBClient';
+
+const findUserByEmail = async (email: string) =>
+  DBClient.instance.user.findFirst({
+    where: { email },
+    select: {
+      id: true,
+      username: true,
+      hash: true,
+    },
+  });
+
+export default findUserByEmail;

services/User/findUserById.ts

@@ -0,0 +1,23 @@
+import DBClient from '@/prisma/DBClient';
+import { z } from 'zod';
+import GetUserSchema from './schema/GetUserSchema';
+
+const findUserById = async (id: string) => {
+  const user: z.infer<typeof GetUserSchema> | null =
+    await DBClient.instance.user.findUnique({
+      where: { id },
+      select: {
+        id: true,
+        username: true,
+        email: true,
+        firstName: true,
+        lastName: true,
+        dateOfBirth: true,
+        createdAt: true,
+      },
+    });
+
+  return user;
+};
+
+export default findUserById;

services/User/findUserByUsername.ts

@@ -0,0 +1,13 @@
+import DBClient from '@/prisma/DBClient';
+
+const findUserByUsername = async (username: string) =>
+  DBClient.instance.user.findFirst({
+    where: { username },
+    select: {
+      id: true,
+      username: true,
+      hash: true,
+    },
+  });
+
+export default findUserByUsername;

services/User/schema/CreateUserValidationSchema.ts

@@ -0,0 +1,37 @@
+import sub from 'date-fns/sub';
+import { z } from 'zod';
+
+const minimumDateOfBirth = sub(new Date(), { years: 19 });
+const CreateUserValidationSchema = z.object({
+  email: z.string().email({ message: 'Email must be a valid email address.' }),
+  // use special characters, numbers, and uppercase letters
+  password: z
+    .string()
+    .min(8, { message: 'Password must be at least 8 characters.' })
+    .refine((password) => /[A-Z]/.test(password), {
+      message: 'Password must contain at least one uppercase letter.',
+    })
+    .refine((password) => /[0-9]/.test(password), {
+      message: 'Password must contain at least one number.',
+    })
+    .refine((password) => /[^a-zA-Z0-9]/.test(password), {
+      message: 'Password must contain at least one special character.',
+    }),
+
+  firstName: z.string().min(1, { message: 'First name must not be empty.' }),
+  lastName: z.string().min(1, { message: 'Last name must not be empty.' }),
+  username: z
+    .string()
+    .min(1, { message: 'Username must not be empty.' })
+    .max(20, { message: 'Username must be less than 20 characters.' }),
+  dateOfBirth: z.string().refine(
+    (dateOfBirth) => {
+      const parsedDateOfBirth = new Date(dateOfBirth);
+
+      return parsedDateOfBirth <= minimumDateOfBirth;
+    },
+    { message: 'You must be at least 19 years old to register.' },
+  ),
+});
+
+export default CreateUserValidationSchema;

services/User/schema/GetUserSchema.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+
+const GetUserSchema = z.object({
+  id: z.string().uuid(),
+  username: z.string(),
+  createdAt: z.date().or(z.string()),
+  updatedAt: z.date().or(z.string()).optional(),
+  email: z.string().email(),
+  firstName: z.string(),
+  lastName: z.string(),
+  dateOfBirth: z.date().or(z.string()),
+});
+
+export default GetUserSchema;

services/User/schema/LoginValidationSchema.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+
+const LoginValidationSchema = z.object({
+  username: z
+    .string({
+      required_error: 'Username is required.',
+      invalid_type_error: 'Username must be a string.',
+    })
+    .min(1, { message: 'Username is required.' }),
+  password: z
+    .string({
+      required_error: 'Password is required.',
+      invalid_type_error: 'Password must be a string.',
+    })
+    .min(1, { message: 'Password is required.' }),
+});
+
+export default LoginValidationSchema;