feat: implement credentials login

implements the credentials login functionality

src/lib/auth/login.ts

@@ -0,0 +1,27 @@
+'use server';
+
+import { z } from 'zod';
+import { loginSchema } from '@/lib/validation/user';
+import { signIn } from '@/auth';
+
+export async function loginAction(data: z.infer<typeof loginSchema>) {
+  try {
+    await signIn('credentials', {
+      ...data,
+      redirect: false,
+    });
+
+    return {
+      error: undefined,
+    };
+  } catch (error: unknown) {
+    if (error instanceof Error) {
+      return {
+        error: error.message.toString(),
+      };
+    }
+    return {
+      error: 'An unknown error occurred.',
+    };
+  }
+}

src/lib/auth/register.ts

@@ -0,0 +1,75 @@
+'use server';
+
+import type { z } from 'zod';
+import bcrypt from 'bcryptjs';
+import { registerSchema } from '@/lib/validation/user';
+import { prisma } from '@/prisma';
+
+export async function registerAction(data: z.infer<typeof registerSchema>) {
+  try {
+    const result = await registerSchema.safeParseAsync(data);
+
+    if (!result.success) {
+      return {
+        error: result.error.errors[0].message,
+      };
+    }
+
+    const { email, password, firstName, lastName, username } = result.data;
+
+    const user = await prisma.user.findUnique({
+      where: {
+        email,
+      },
+    });
+
+    if (user) {
+      return {
+        error: 'User already exist with this email',
+      };
+    }
+
+    const existingUsername = await prisma.user.findUnique({
+      where: {
+        name: username,
+      },
+    });
+
+    if (existingUsername) {
+      return {
+        error: 'Username already exists',
+      };
+    }
+
+    const passwordHash = await bcrypt.hash(password, 10);
+
+    await prisma.$transaction(async (tx) => {
+      const { id } = await tx.user.create({
+        data: {
+          email,
+          name: username,
+          password_hash: passwordHash,
+          first_name: firstName,
+          last_name: lastName,
+          emailVerified: new Date(), // TODO: handle email verification
+        },
+      });
+
+      await tx.account.create({
+        data: {
+          userId: id,
+          type: 'credentials',
+          provider: 'credentials',
+          providerAccountId: id,
+        },
+      });
+    });
+
+    return {};
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  } catch (_error) {
+    return {
+      error: 'System error. Please contact support',
+    };
+  }
+}

src/lib/hooks/useZodForm.tsx

@@ -0,0 +1,14 @@
+import { zodResolver } from '@hookform/resolvers/zod';
+import { useForm } from 'react-hook-form';
+import { z } from 'zod';
+
+export default function useZodForm<
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  Schema extends z.ZodType<any, any, any>,
+  Values extends z.infer<Schema>,
+>(schema: Schema, defaultValues?: Values) {
+  return useForm<Values>({
+    resolver: zodResolver(schema),
+    defaultValues,
+  });
+}

src/lib/validation/user.ts

@@ -0,0 +1,67 @@
+import zod from 'zod';
+
+export const loginSchema = zod.object({
+  email: zod
+    .string()
+    .email('Invalid email address')
+    .min(3, 'Email is required')
+    .or(
+      zod
+        .string()
+        .min(3, 'Username is required')
+        .max(32, 'Username must be at most 32 characters long')
+        .regex(
+          /^[a-zA-Z0-9_]+$/,
+          'Username can only contain letters, numbers, and underscores',
+        ),
+    ),
+  password: zod.string().min(1, 'Password is required'),
+});
+
+export const registerSchema = zod
+  .object({
+    firstName: zod
+      .string()
+      .min(1, 'First name is required')
+      .max(32, 'First name must be at most 32 characters long'),
+    lastName: zod
+      .string()
+      .min(1, 'Last name is required')
+      .max(32, 'Last name must be at most 32 characters long'),
+    email: zod
+      .string()
+      .email('Invalid email address')
+      .min(3, 'Email is required'),
+    password: zod
+      .string()
+      .min(8, 'Password must be at least 8 characters long')
+      .max(128, 'Password must be at most 128 characters long'),
+    confirmPassword: zod
+      .string()
+      .min(8, 'Password must be at least 8 characters long')
+      .max(128, 'Password must be at most 128 characters long'),
+    username: zod
+      .string()
+      .min(3, 'Username is required')
+      .max(32, 'Username must be at most 32 characters long')
+      .regex(
+        /^[a-zA-Z0-9_]+$/,
+        'Username can only contain letters, numbers, and underscores',
+      ),
+  })
+  .refine((data) => data.password === data.confirmPassword, {
+    message: 'Passwords do not match',
+    path: ['confirmPassword'],
+  })
+  .refine(
+    (data) =>
+      !data.password.includes(data.firstName) &&
+      !data.password.includes(data.lastName) &&
+      !data.password.includes(data.email) &&
+      !data.password.includes(data.username),
+    {
+      message:
+        'Password cannot contain your first name, last name, email, or username',
+      path: ['password'],
+    },
+  );