@@ -73,9 +79,11 @@ export default function RegisterPage() {
Register
-
diff --git a/src/app/globals.css b/src/app/globals.css
index bd6213e..7d76737 100644
--- a/src/app/globals.css
+++ b/src/app/globals.css
@@ -1,3 +1,5 @@
-@tailwind base;
+@layer tailwind{
+ @tailwind base;
+}
@tailwind components;
@tailwind utilities;
\ No newline at end of file
diff --git a/src/core/db/index.ts b/src/core/db/index.ts
new file mode 100644
index 0000000..0273c94
--- /dev/null
+++ b/src/core/db/index.ts
@@ -0,0 +1,15 @@
+import { PrismaClient } from "@prisma/client";
+
+const prismaClientSingleton = () => {
+ return new PrismaClient();
+};
+
+declare global {
+ var prisma: undefined | ReturnType
;
+}
+
+const prisma = globalThis.prisma ?? prismaClientSingleton();
+
+export default prisma;
+
+if (process.env.NODE_ENV !== "production") globalThis.prisma = prisma;
diff --git a/src/core/error/BaseError.ts b/src/core/error/BaseError.ts
new file mode 100644
index 0000000..9c82306
--- /dev/null
+++ b/src/core/error/BaseError.ts
@@ -0,0 +1,31 @@
+export const BaseErrorCodes = ["UNKOWN_ERROR"] as const;
+
+interface ErrorOptions {
+ message?: string;
+ errorCode: (typeof BaseErrorCodes)[number] | (string & {});
+}
+
+class BaseError extends Error {
+ public readonly errorCode: (typeof BaseErrorCodes)[number] | (string & {});
+
+ constructor(options: ErrorOptions) {
+ super(options.message ?? "Undetermined Error");
+ this.errorCode = options.errorCode ?? "UNKOWN_ERROR";
+
+ Object.setPrototypeOf(this, new.target.prototype);
+
+ console.error("error:", options)
+ }
+
+ getActionResponseObject() {
+ return {
+ success: false,
+ error: {
+ message: this.message,
+ errorCode: this.errorCode,
+ },
+ } as const;
+ }
+}
+
+export default BaseError;
diff --git a/src/modules/auth/actions/createUser.ts b/src/modules/auth/actions/createUser.ts
new file mode 100644
index 0000000..2df4d5d
--- /dev/null
+++ b/src/modules/auth/actions/createUser.ts
@@ -0,0 +1,105 @@
+"use server";
+import { z } from "zod";
+import prisma from "@/core/db";
+import { cookies } from "next/headers";
+import { redirect } from "next/navigation";
+import { hashPassword } from "../utils/hashPassword";
+import { createJwtToken } from "../utils/createJwtToken";
+
+/**
+ * Interface for the schema of a new user.
+ */
+interface CreateUserSchema {
+ name: string;
+ email: string;
+ password: string;
+}
+
+/**
+ * Validation schema for creating a user.
+ */
+const createUserSchema = z
+ .object({
+ name: z.string(),
+ email: z.string().email(),
+ password: z.string().min(6),
+ passwordConfirmation: z.string().optional(),
+ })
+ .refine((data) => data.password === data.passwordConfirmation, {
+ message: "Password confirmation must match the password",
+ path: ["passwordConfirmation"],
+ });
+
+/**
+ * Creates a new user in the system.
+ *
+ * @param formData - The form data containing user details.
+ * @returns An object indicating the result of the operation.
+ */
+export default async function createUser(formData: FormData) {
+ //TODO: Add Throttling
+ //TODO: Add validation check if the user is already logged in
+
+ try {
+ const parsedData = {
+ email: formData.get("email")?.toString() ?? "",
+ name: formData.get("name")?.toString() ?? "",
+ password: formData.get("password")?.toString() ?? "",
+ passwordConfirmation: formData
+ .get("passwordConfirmation")
+ ?.toString(),
+ };
+ const validatedFields = createUserSchema.safeParse(parsedData);
+
+ if (!validatedFields.success) {
+ return {
+ success: false,
+ error: {
+ message: "",
+ errors: validatedFields.error.flatten().fieldErrors,
+ },
+ };
+ }
+
+ const existingUser = await prisma.user.findUnique({
+ where: { email: validatedFields.data.email },
+ });
+
+ if (existingUser) {
+ return {
+ success: false,
+ error: {
+ message: "",
+ errors: {
+ email: ["Email already exists"],
+ },
+ },
+ };
+ }
+
+ const user = await prisma.user.create({
+ data: {
+ name: validatedFields.data.name,
+ email: validatedFields.data.email,
+ passwordHash: await hashPassword(validatedFields.data.password),
+ },
+ });
+
+ const token = createJwtToken({ id: user.id });
+ cookies().set("token", token);
+ } catch (e: unknown) {
+ // Handle unexpected errors
+ console.error(e);
+ //@ts-ignore
+ console.log(e.message);
+ return {
+ success: false,
+ error: {
+ message:
+ "An unexpected error occurred on the server. Please try again or contact the administrator.",
+ },
+ };
+ }
+
+ redirect("/dashboard");
+}
diff --git a/src/modules/auth/actions/getUser.ts b/src/modules/auth/actions/getUser.ts
new file mode 100644
index 0000000..6708827
--- /dev/null
+++ b/src/modules/auth/actions/getUser.ts
@@ -0,0 +1,39 @@
+"use server";
+
+import { cookies } from "next/headers";
+import "server-only";
+import getUserFromToken from "../utils/getUserFromToken";
+import AuthError from "../error/AuthError";
+
+/**
+ * Retrieves the user details based on the JWT token from cookies.
+ * This function is designed to be used in a server-side context within a Next.js application.
+ * It attempts to parse the user's token, fetch the user's details, and format the response.
+ * If the token is invalid or the user cannot be found, it gracefully handles these cases.
+ *
+ * @returns A promise that resolves to the user's details object or null if the user cannot be authenticated or an error occurs.
+ * @throws an error if an unexpected error occurs during execution.
+ */
+export default async function getUser() {
+ try {
+ const token = cookies().get("token");
+
+ if (!token) return null;
+
+ const user = await getUserFromToken(token.value);
+
+ if (!user) return null;
+
+ return {
+ name: user.name ?? "",
+ email: user.email ?? "",
+ photoUrl: user.photoProfile?.path ?? null,
+ };
+ } catch (e: unknown) {
+ // Handle specific authentication errors gracefully
+ if (e instanceof AuthError && e.errorCode === "INVALID_JWT_TOKEN") {
+ return null;
+ }
+ throw e;
+ }
+}
diff --git a/src/modules/auth/actions/guestOnly.ts b/src/modules/auth/actions/guestOnly.ts
new file mode 100644
index 0000000..86d5011
--- /dev/null
+++ b/src/modules/auth/actions/guestOnly.ts
@@ -0,0 +1,12 @@
+"use server";
+
+import { redirect } from "next/navigation";
+import getUser from "./getUser";
+
+export default async function guestOnly() {
+ const user = await getUser();
+
+ if (user) {
+ redirect("dashboard");
+ }
+}
diff --git a/src/modules/auth/actions/logout.ts b/src/modules/auth/actions/logout.ts
new file mode 100644
index 0000000..96cd9f8
--- /dev/null
+++ b/src/modules/auth/actions/logout.ts
@@ -0,0 +1,16 @@
+"use server";
+
+import { cookies } from "next/headers";
+import { redirect } from "next/navigation";
+import "server-only";
+
+/**
+ * Handles user logout by deleting the authentication token and redirecting to the login page.
+ * This function is intended to be used on the server side.
+ *
+ * @returns A promise that resolves when the logout process is complete.
+ */
+export default async function logout() {
+ cookies().delete("token");
+ redirect("/login");
+}
diff --git a/src/modules/auth/actions/signIn.ts b/src/modules/auth/actions/signIn.ts
new file mode 100644
index 0000000..0b85a4c
--- /dev/null
+++ b/src/modules/auth/actions/signIn.ts
@@ -0,0 +1,99 @@
+"use server";
+import prisma from "@/core/db";
+import { User } from "@prisma/client";
+import { cookies } from "next/headers";
+import { redirect } from "next/navigation";
+import { revalidatePath } from "next/cache";
+import AuthError from "../error/AuthError";
+import comparePassword from "../utils/comparePassword";
+import { createJwtToken } from "../utils/createJwtToken";
+
+/**
+ * Handles the sign-in process for a user.
+ *
+ * This function validates a user's credentials (email and password), checks against the database,
+ * and on successful validation, redirects the user to the dashboard and sets a cookie with a JWT token.
+ * If the validation fails at any stage, it throws a custom AuthError.
+ *
+ * @param prevState - The previous state of the application, not currently used.
+ * @param rawFormData - The raw form data containing the user's email and password.
+ * @returns A promise that resolves to a redirect to the dashboard on successful authentication,
+ * or an object containing error details on failure.
+ * @throws Specific authentication error based on the failure stage.
+ */
+export default async function signIn(prevState: any, rawFormData: FormData) {
+ //TODO: Add Throttling
+ //TODO: Add validation check if the user is already logged in
+ try {
+ const formData = {
+ email: rawFormData.get("email") as string,
+ password: rawFormData.get("password") as string,
+ };
+
+ // Retrieve user from the database by email
+ const user = await prisma.user.findUnique({
+ where: { email: formData.email },
+ });
+
+ // Throw if user not found
+ if (!user)
+ throw new AuthError({
+ errorCode: "EMAIL_NOT_FOUND",
+ message: "Email or Password does not match",
+ });
+
+ // Throw if user has no password hash
+ // TODO: Add check if the user uses another provider
+ if (!user.passwordHash)
+ throw new AuthError({ errorCode: "EMPTY_USER_HASH" });
+
+ // Compare the provided password with the user's stored password hash
+ const isMatch = await comparePassword(
+ formData.password,
+ user.passwordHash
+ );
+ if (!isMatch)
+ throw new AuthError({
+ errorCode: "INVALID_CREDENTIALS",
+ message: "Email or Password does not match",
+ });
+
+ //Set cookie
+ //TODO: Auth: Add expiry
+ const token = createJwtToken({ id: user.id });
+
+ cookies().set("token", token);
+ } catch (e: unknown) {
+ // Custom error handling for authentication errors
+ if (e instanceof AuthError) {
+ // Specific error handling for known authentication errors
+ switch (e.errorCode) {
+ case "EMAIL_NOT_FOUND":
+ case "INVALID_CREDENTIALS":
+ return {
+ errors: {
+ message:
+ "Email/Password combination is incorrect. Please try again.",
+ },
+ };
+ default:
+ // Handle other types of authentication errors
+ return {
+ errors: {
+ message: e.message,
+ },
+ };
+ }
+ }
+
+ // Generic error handling for unexpected server errors
+ return {
+ errors: {
+ message:
+ "An unexpected error occurred on the server. Please try again or contact the administrator.",
+ },
+ };
+ }
+
+ redirect("/dashboard");
+}
diff --git a/src/modules/auth/authConfig.ts b/src/modules/auth/authConfig.ts
new file mode 100644
index 0000000..ddc99f0
--- /dev/null
+++ b/src/modules/auth/authConfig.ts
@@ -0,0 +1,5 @@
+const authConfig = {
+ saltRounds: 10,
+};
+
+export default authConfig;
diff --git a/src/modules/auth/error/AuthError.ts b/src/modules/auth/error/AuthError.ts
new file mode 100644
index 0000000..beee2b2
--- /dev/null
+++ b/src/modules/auth/error/AuthError.ts
@@ -0,0 +1,28 @@
+import BaseError from "@/core/error/BaseError";
+
+export const AuthErrorCodes = [
+ "EMAIL_NOT_FOUND",
+ "EMPTY_USER_HASH",
+ "INVALID_CREDENTIALS",
+ "INVALID_JWT_TOKEN",
+ "JWT_SECRET_EMPTY",
+ "USER_ALREADY_EXISTS",
+] as const;
+
+interface AuthErrorOptions {
+ message?: string;
+ errorCode: (typeof AuthErrorCodes)[number] | (string & {});
+}
+
+export default class AuthError extends BaseError {
+ errorCode: (typeof AuthErrorCodes)[number] | (string & {});
+
+ constructor(options: AuthErrorOptions) {
+ super({
+ errorCode: options.errorCode,
+ message: options.message,
+ });
+
+ this.errorCode = options.errorCode;
+ }
+}
diff --git a/src/modules/auth/types/UserClaims.d.ts b/src/modules/auth/types/UserClaims.d.ts
new file mode 100644
index 0000000..7d3e21a
--- /dev/null
+++ b/src/modules/auth/types/UserClaims.d.ts
@@ -0,0 +1,7 @@
+import { User } from "@prisma/client";
+
+type UserClaims = {
+ id: User["id"];
+};
+
+export default UserClaims;
diff --git a/src/modules/auth/utils/comparePassword.ts b/src/modules/auth/utils/comparePassword.ts
new file mode 100644
index 0000000..218192e
--- /dev/null
+++ b/src/modules/auth/utils/comparePassword.ts
@@ -0,0 +1,17 @@
+import bcrypt from "bcrypt";
+
+/**
+ * Compares a plain text password with a hashed password.
+ *
+ * @param password - The plain text password to compare.
+ * @param hash - The hashed password to compare against.
+ * @returns True if the passwords match, false otherwise.
+ */
+async function comparePassword(
+ password: string,
+ hash: string
+): Promise {
+ return bcrypt.compare(password, hash);
+}
+
+export default comparePassword;
diff --git a/src/modules/auth/utils/createJwtToken.ts b/src/modules/auth/utils/createJwtToken.ts
new file mode 100644
index 0000000..abb1656
--- /dev/null
+++ b/src/modules/auth/utils/createJwtToken.ts
@@ -0,0 +1,20 @@
+import { SignOptions } from "jsonwebtoken";
+import UserClaims from "../types/UserClaims";
+import AuthError from "../error/AuthError";
+import jwt from "jsonwebtoken";
+
+/**
+ * Creates a JWT token based on user claims.
+ *
+ * @param userClaims - The user claims to encode in the JWT.
+ * @param options - Optional signing options.
+ * @returns The generated JWT token.
+ */
+export function createJwtToken(
+ userClaims: UserClaims,
+ options?: SignOptions
+): string {
+ const secret = process.env.JWT_SECRET;
+ if (!secret) throw new AuthError({ errorCode: "JWT_SECRET_EMPTY" });
+ return jwt.sign(userClaims, secret, options);
+}
diff --git a/src/modules/auth/utils/decodeJwtToken.ts b/src/modules/auth/utils/decodeJwtToken.ts
new file mode 100644
index 0000000..f2b3883
--- /dev/null
+++ b/src/modules/auth/utils/decodeJwtToken.ts
@@ -0,0 +1,21 @@
+import jwt, { JwtPayload } from "jsonwebtoken";
+import AuthError from "../error/AuthError";
+
+/**
+ * Decodes a JWT token and retrieves the payload.
+ *
+ * @param token - The JWT token to decode.
+ * @returns The decoded payload.
+ */
+function decodeJwtToken(token: string): JwtPayload | string {
+ const secret = process.env.JWT_SECRET;
+ if (!secret) throw new AuthError({ errorCode: "JWT_SECRET_NOT_EMPTY" });
+
+ try {
+ return jwt.verify(token, secret) as JwtPayload;
+ } catch (error) {
+ throw new AuthError({ errorCode: "INVALID_JWT_TOKEN" });
+ }
+}
+
+export default decodeJwtToken;
diff --git a/src/modules/auth/utils/getUserFromToken.ts b/src/modules/auth/utils/getUserFromToken.ts
new file mode 100644
index 0000000..a29a8b7
--- /dev/null
+++ b/src/modules/auth/utils/getUserFromToken.ts
@@ -0,0 +1,34 @@
+import { cache } from "react";
+import decodeJwtToken from "./decodeJwtToken";
+import prisma from "@/core/db";
+
+/**
+ * Retrieves user data from the database based on the provided JWT token.
+ *
+ * This function decodes the JWT token to extract the user ID, and then queries the database using Prisma
+ * to fetch the user's details, including the profile photo, roles, and direct permissions.
+ *
+ * @param token - The JWT token containing the user's ID.
+ * @returns The user's data if the user exists, or null if no user is found.
+ * Throws an error if the token is invalid or the database query fails.
+ */
+const getUserFromToken = cache(async (token: string) => {
+ // Decode the JWT token to extract the user ID
+ const decodedToken = decodeJwtToken(token) as { id: string; iat: number };
+
+ // Fetch the user from the database
+ const user = await prisma.user.findFirst({
+ include: {
+ photoProfile: true,
+ roles: true,
+ directPermissions: true,
+ },
+ where: {
+ id: decodedToken.id,
+ },
+ });
+
+ return user;
+});
+
+export default getUserFromToken;
diff --git a/src/modules/auth/utils/hashPassword.ts b/src/modules/auth/utils/hashPassword.ts
new file mode 100644
index 0000000..3323eb6
--- /dev/null
+++ b/src/modules/auth/utils/hashPassword.ts
@@ -0,0 +1,14 @@
+import bcrypt from "bcrypt";
+import authConfig from "../authConfig";
+
+/**
+ * Hashes a plain text password using bcrypt.
+ *
+ * @param password - The plain text password to hash.
+ * @returns The hashed password.
+ */
+export async function hashPassword(password: string): Promise {
+ return bcrypt.hash(password, authConfig.saltRounds);
+}
+
+export default hashPassword;