@cristianrg/fastpress 1.0.1

package/dist/core/decorators/Controller.js

@@ -0,0 +1,140 @@
+import { Router } from "express";
+import "reflect-metadata";
+import { CONTROLLER_ROUTES } from "./Methods.js";
+import { ServerResponse } from "../../shared/models/ServerResponse.js";
+import { Context } from "../../shared/models/Context.js";
+import { PARAM_METADATA_KEY } from "../../common/decorators/Param.js";
+import logger from "../../shared/repository/Logger.js";
+/**
+ * Get all route definitions for a controller class and its parent classes
+ */
+function getAllRoutes(constructor) {
+    const routes = [];
+    const currentRoutes = CONTROLLER_ROUTES.get(constructor) || [];
+    routes.push(...currentRoutes);
+    // Get routes from parent classes
+    let baseProto = Object.getPrototypeOf(constructor.prototype);
+    while (baseProto && baseProto.constructor !== Object) {
+        const baseConstructor = baseProto.constructor;
+        const baseRoutes = CONTROLLER_ROUTES.get(baseConstructor) || [];
+        for (const baseRoute of baseRoutes) {
+            const routeExists = routes.some(r => r.path === baseRoute.path &&
+                r.method === baseRoute.method);
+            if (!routeExists) {
+                routes.push(baseRoute);
+            }
+        }
+        // Move up the prototype chain
+        baseProto = Object.getPrototypeOf(baseProto);
+    }
+    return routes;
+}
+const paramTypeStrategy = {
+    "param": (ctx, propertyKey) => propertyKey ? ctx.params[propertyKey] : ctx.params,
+    "query": (ctx, propertyKey) => propertyKey ? ctx.query[propertyKey] : ctx.query,
+    "body": (ctx, propertyKey) => propertyKey ? ctx.body[propertyKey] : ctx.body,
+    "user": (ctx) => ctx.user,
+    "request": (ctx) => ctx.req,
+    "response": (ctx) => ctx.res
+};
+async function handleParams(ctx, paramMetadata) {
+    const args = new Array(paramMetadata.length);
+    if (paramMetadata.length == 0) {
+        return [ctx];
+    }
+    for (const param of paramMetadata) {
+        let value;
+        const extractor = paramTypeStrategy[param.type];
+        if (!extractor) {
+            throw new Error(`Unsupported parameter type: ${param.type}`);
+        }
+        value = extractor(ctx, param.propertyKey);
+        if (param.pipes && param.pipes.length > 0) {
+            if (value === undefined && param.isOptional) {
+                args[param.index] = undefined;
+                continue;
+            }
+            for (const PipeClass of param.pipes) {
+                const pipeInstance = (typeof PipeClass === "function" ? new PipeClass() : PipeClass);
+                value = await pipeInstance.transform(value, ctx);
+            }
+        }
+        args[param.index] = value;
+    }
+    return args;
+}
+/**
+ * Controller decorator to define a controller class and its route prefix. It also sets up the router for the controller based on the defined routes and their handlers.
+ * @param prefix The prefix to be added to all routes defined in this controller. For example, if you set the prefix to "/users" and you have a method decorated with `@Get("/")`, the full path for that route will be "/users/".
+ * @returns
+ */
+export function Controller(prefix) {
+    return (target) => {
+        const router = Router();
+        // Get routes for this controller class and all parent classes
+        const routes = getAllRoutes(target);
+        const instance = new target();
+        for (const route of routes) {
+            const guards = Reflect.getMetadata("custom:guards", target.prototype, route.handlerName) || [];
+            const guardInstances = guards.map((guard) => (typeof guard === "function" ? new guard() : guard));
+            const hooks = Reflect.getMetadata("custom:hooks", target.prototype, route.handlerName) || [];
+            const hookInstances = hooks.map((hook) => (typeof hook === "function" ? new hook() : hook));
+            const paramMetadata = Reflect.getMetadata(PARAM_METADATA_KEY, target.prototype, route.handlerName) || [];
+            const handler = async (req, res, next) => {
+                const ctx = new Context(req, res, next);
+                const timestamp = Date.now();
+                try {
+                    const handlerFunction = instance[route.handlerName];
+                    if (typeof handlerFunction !== 'function') {
+                        return next(new Error(`Route handler '${route.handlerName}' not found in ${target.name}`));
+                    }
+                    logger.info(`${req.method.toUpperCase()} ${req.originalUrl}`);
+                    for (const guard of guardInstances) {
+                        const canActivateResult = await guard.canActivate(ctx);
+                        if (canActivateResult instanceof Object && !canActivateResult.allowed) {
+                            return res.status(canActivateResult.statusCode || 403).json(new ServerResponse(canActivateResult.statusCode || 403, canActivateResult.message || "Forbidden"));
+                        }
+                        else if (!canActivateResult) {
+                            return res.status(403).json(new ServerResponse(403, "Forbidden"));
+                        }
+                    }
+                    const args = await handleParams(ctx, paramMetadata);
+                    for (const hook of hookInstances) {
+                        const earlyResult = await hook.before(ctx);
+                        if (earlyResult instanceof ServerResponse) {
+                            return res.status(earlyResult.statusCode).json(earlyResult);
+                        }
+                    }
+                    const result = await handlerFunction.call(instance, ...args);
+                    let finalResult = result;
+                    for (const hook of hookInstances) {
+                        const hookResult = await hook.after(ctx, finalResult);
+                        if (hookResult instanceof ServerResponse) {
+                            finalResult = hookResult;
+                        }
+                    }
+                    if (finalResult instanceof ServerResponse) {
+                        res.status(finalResult.statusCode).json(finalResult);
+                    }
+                    else if (finalResult !== undefined) {
+                        res.json(finalResult);
+                    }
+                }
+                catch (error) {
+                    if (error instanceof ServerResponse) {
+                        logger.error(`Error in ${target.name}.${route.handlerName}: ${error.message}`);
+                        return res.status(error.statusCode).json(error);
+                    }
+                    next(error);
+                }
+                finally {
+                    const elapsed = Date.now() - timestamp;
+                    logger.info(`${req.method.toUpperCase()} ${req.originalUrl} ${res.statusCode} - ${elapsed}ms`);
+                }
+            };
+            router[route.method](route.path, handler);
+        }
+        Reflect.defineMetadata("router", router, target);
+        Reflect.defineMetadata("prefix", prefix, target);
+    };
+}

package/dist/core/decorators/Methods.js

@@ -0,0 +1,54 @@
+import "reflect-metadata";
+// Use a Map to store routes for each controller class
+// The key is the controller's constructor function and the value is an array of routes
+export const CONTROLLER_ROUTES = new Map();
+function createMethodDecorator(method) {
+    return (path) => {
+        return (target, propertyKey, descriptor) => {
+            // Get the actual class constructor
+            // If target is a prototype, target.constructor is the class constructor
+            // Otherwise, it's a static method and target is the constructor itself
+            const constructor = typeof target === 'function' ? target : target.constructor;
+            // Get existing routes for this controller class or initialize a new array
+            const routes = CONTROLLER_ROUTES.get(constructor) || [];
+            // Check if this route already exists to avoid duplicates
+            const routeExists = routes.some(r => r.path === path &&
+                r.method === method &&
+                r.handlerName === propertyKey);
+            if (!routeExists) {
+                // Add the new route
+                routes.push({
+                    path,
+                    method,
+                    handlerName: propertyKey
+                });
+                // Store the updated routes back in the map
+                CONTROLLER_ROUTES.set(constructor, routes);
+            }
+        };
+    };
+}
+/**
+ * Get decorator. Adds a GET route to the controller.
+ * @param path The route path.
+ * @returns `ServerResponse` or `Promise<ServerResponse>` from the decorated method.
+ */
+export const Get = createMethodDecorator("get");
+/**
+ * Post decorator. Adds a POST route to the controller.
+ * @param path The route path.
+ * @returns `ServerResponse` or `Promise<ServerResponse>` from the decorated method.
+ */
+export const Post = createMethodDecorator("post");
+/**
+ * Put decorator. Adds a PUT route to the controller.
+ * @param path The route path.
+ * @returns `ServerResponse` or `Promise<ServerResponse>` from the decorated method.
+ */
+export const Put = createMethodDecorator("put");
+/**
+ * Delete decorator. Adds a DELETE route to the controller.
+ * @param path The route path.
+ * @returns `ServerResponse` or `Promise<ServerResponse>` from the decorated method.
+ */
+export const Delete = createMethodDecorator("delete");

package/dist/core/decorators/UseGuards.js

@@ -0,0 +1,11 @@
+/**
+ * Guard decorator to apply guards to a route handler. Guards are functions that can be executed before the route handler is called, allowing you to perform authorization checks, validate user permissions, etc.
+ * @param guards An array of Guard instances to be applied to the route handler. The guards will be executed in the order they are provided in the array.
+ * @returns
+ */
+export function UseGuards(...guards) {
+    return (target, propertyKey, descriptor) => {
+        const existingGuards = Reflect.getMetadata("custom:guards", target, propertyKey) || [];
+        Reflect.defineMetadata("custom:guards", [...existingGuards, ...guards], target, propertyKey);
+    };
+}

package/dist/core/decorators/UseHooks.js

@@ -0,0 +1,11 @@
+/**
+ * Hook decorator to apply hooks to a route handler. Hooks are functions that can be executed before or after the route handler is called, allowing you to perform additional logic such as logging, modifying the request/response, etc.
+ * @param hooks An array of Hook instances to be applied to the route handler. The hooks will be executed in the order they are provided in the array.
+ * @returns
+ */
+export function UseHooks(...hooks) {
+    return (target, propertyKey, descriptor) => {
+        const existingHooks = Reflect.getMetadata("custom:hooks", target, propertyKey) || [];
+        Reflect.defineMetadata("custom:hooks", [...existingHooks, ...hooks], target, propertyKey);
+    };
+}

package/dist/core/decorators/UseMiddleware.js

@@ -0,0 +1,11 @@
+/**
+ * Middleware decorator to apply middlewares to a controller class. Middlewares are functions that can be executed before the route handlers of the controller are called, allowing you to perform tasks such as authentication, logging, etc.
+ * @param middlewares An array of Middleware instances to be applied to the controller class. The middlewares will be executed in the order they are provided in the array.
+ * @returns
+ */
+export function UseMiddleware(...middlewares) {
+    return (target) => {
+        const existingMiddlewares = Reflect.getMetadata("custom:middlewares", target) || [];
+        Reflect.defineMetadata("custom:middlewares", [...existingMiddlewares, ...middlewares], target);
+    };
+}

package/dist/core/discovery/index.js

@@ -0,0 +1,30 @@
+import { glob } from "glob";
+import path from "path";
+import { pathToFileURL } from "url";
+import { __dirName, __fileName } from "./utility.js";
+export const discovery = async () => {
+    // Determine the file extension based on the current file's extension (either .ts or .js)
+    const extension = __fileName.endsWith(".js") ? "js" : "ts";
+    const controllersPath = path.resolve(__dirName, "../../modules");
+    const internalControllerPaths = path.resolve(__dirName, "../modules");
+    const controllers = await glob(`${controllersPath}/**/**.controller.${extension}`);
+    const internalControllers = await glob(`${internalControllerPaths}/**/**.controller.${extension}`);
+    const modules = [];
+    for (const controllerPath of internalControllers) {
+        const absolutePath = path.resolve(controllerPath);
+        const fileURL = pathToFileURL(absolutePath).href;
+        const module = await import(fileURL);
+        if (module.default) {
+            modules.push(module.default);
+        }
+    }
+    for (const controllerPath of controllers) {
+        const absolutePath = path.resolve(controllerPath);
+        const fileURL = pathToFileURL(absolutePath).href;
+        const module = await import(fileURL);
+        if (module.default) {
+            modules.push(module.default);
+        }
+    }
+    return modules;
+};

package/dist/core/discovery/utility.js

@@ -0,0 +1,5 @@
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+const __fileName = fileURLToPath(import.meta.url);
+const __dirName = dirname(__fileName);
+export { __dirName, __fileName };

package/dist/core/loader/index.js

@@ -0,0 +1,23 @@
+import "reflect-metadata";
+import { Context } from "../../shared/models/Context.js";
+export function registerControllers(app, controllers) {
+    for (const controller of controllers) {
+        const controllerPrefix = Reflect.getMetadata("prefix", controller);
+        const router = Reflect.getMetadata("router", controller);
+        const middlewares = Reflect.getMetadata("custom:middlewares", controller) || [];
+        if (router) {
+            if (middlewares.length > 0) {
+                app.use(controllerPrefix, ...middlewares.map(mw => {
+                    const middlewareInstance = typeof mw === "function" ? new mw() : mw;
+                    return (req, res, next) => {
+                        const ctx = new Context(req, res, next);
+                        return middlewareInstance.handle(ctx);
+                    };
+                }), router);
+            }
+            else {
+                app.use(controllerPrefix, router);
+            }
+        }
+    }
+}

package/dist/core/server.js

@@ -0,0 +1,43 @@
+import express from "express";
+import cors from "cors";
+import conf, { initializeConfig } from "../conf/index.js";
+import { registerControllers } from "./loader/index.js";
+import { discovery } from "./discovery/index.js";
+import { initializePrisma } from "../common/prisma/index.js";
+const corsOptions = {
+    origin: (origin, callback) => {
+        if (!origin || conf.ALLOWED_ORIGINS.includes(origin))
+            callback(null, true);
+        else
+            callback(new Error("Not allowed by CORS"), false);
+    }
+};
+const bootstrap = async () => {
+    const modules = await discovery();
+    const app = express();
+    app.use(express.json());
+    app.use(express.urlencoded({ extended: true }));
+    app.use(cors(corsOptions));
+    registerControllers(app, modules);
+    return app;
+};
+const createServer = async (onStart) => {
+    let app;
+    try {
+        await initializeConfig();
+        initializePrisma();
+        app = await bootstrap();
+        const port = conf.PORT || 3000;
+        app.listen(port, () => {
+            console.log(`Amazing! \nYour server is running on port ${port}`);
+            if (onStart)
+                onStart(app);
+        });
+    }
+    catch (error) {
+        console.error("Failed to start the server:", error);
+        throw error;
+    }
+    return app;
+};
+export { createServer };

package/dist/index.js

@@ -0,0 +1,40 @@
+// Core Decorators
+export * from './core/decorators/Controller.js';
+export * from './core/decorators/Methods.js';
+export * from './core/decorators/UseMiddleware.js';
+export * from './core/decorators/UseGuards.js';
+export * from './core/decorators/UseHooks.js';
+// Models
+export * from './shared/models/Context.js';
+export * from './shared/models/Guard.js';
+export * from './shared/models/Hook.js';
+export * from './shared/models/Logger.js';
+export * from './shared/models/Middleware.js';
+export * from './shared/models/ServerResponse.js';
+// Middlewares
+export * from './shared/middlewares/Auth.js';
+export * from './shared/middlewares/Sanitizer.js';
+// Repository
+export * from './shared/repository/BaseController.js';
+export * from './shared/repository/Service.js';
+export * from './shared/repository/Logger.js';
+// Common decorators
+export * from './common/decorators/Body.js';
+export * from './common/decorators/Param.js';
+export * from './common/decorators/Query.js';
+export * from './common/decorators/Req.js';
+export * from './common/decorators/User.js';
+// Common loggers
+export * from './common/loggers/Winston.js';
+// Common pipes
+export * from './common/pipes/ParseIntPipe.js';
+export * from './common/pipes/ZodValidationPipe.js';
+export * from './common/pipes/Pipe.js'; // Pipe model
+// Prisma instance
+export { default as prisma, getPrisma, initializePrisma } from './common/prisma/index.js';
+// Redis instance
+export * from './common/redis/index.js';
+// Utilities
+export * from './common/util/index.js';
+// Core
+export * from './core/server.js';

package/dist/modules/auth/auth.controller.js

@@ -0,0 +1,140 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Body } from "../../common/decorators/Body.js";
+import { Req } from "../../common/decorators/Req.js";
+import { ZodValidationPipe } from "../../common/pipes/ZodValidationPipe.js";
+import { Controller } from "../../core/decorators/Controller.js";
+import { Get, Post } from "../../core/decorators/Methods.js";
+import { LoginUserSchema, SignupUserSchema } from "./auth.zod.schemas.js";
+import { AuthService } from "./auth.service.js";
+import { ServerResponse } from "../../shared/models/ServerResponse.js";
+import logger from "../../shared/repository/Logger.js";
+import conf from "../../conf/index.js";
+let AuthController = class AuthController {
+    async login(body, req) {
+        const { email, password } = body;
+        const sessionId = req.headers.cookie?.split(';').find(cookie => cookie.trim().startsWith('session='))?.split('=')[1] || undefined;
+        try {
+            const user = await AuthService.login(email, password);
+            const { jwt } = await AuthService.generateAccessToken(user.id);
+            const { rjwt } = await AuthService.generateRefreshToken(user.id, sessionId);
+            req.res?.cookie("jwt", jwt.token, {
+                httpOnly: true,
+                secure: conf.ENV === "production",
+                sameSite: "strict",
+                maxAge: jwt.expiresIn
+            });
+            req.res?.cookie("rjwt", rjwt.token, {
+                httpOnly: true,
+                secure: conf.ENV === "production",
+                sameSite: "strict",
+                maxAge: rjwt.expiresIn
+            });
+            if (!sessionId) {
+                req.res?.cookie("session", rjwt.token, {
+                    httpOnly: true,
+                    secure: conf.ENV === "production",
+                    sameSite: "strict",
+                    maxAge: rjwt.expiresIn
+                });
+            }
+            return new ServerResponse(200, "Login successful", { user });
+        }
+        catch (error) {
+            logger.error(`Login error for email ${email}: ${error instanceof Error ? error.message : String(error)}`);
+            return new ServerResponse(401, "Invalid email or password");
+        }
+    }
+    async signup(body, req) {
+        const { email, password, name } = body;
+        try {
+            const user = await AuthService.signup(email, password, name);
+            const { jwt } = await AuthService.generateAccessToken(user.id);
+            const { rjwt } = await AuthService.generateRefreshToken(user.id);
+            req.res?.cookie("jwt", jwt.token, {
+                httpOnly: true,
+                secure: conf.ENV === "production",
+                sameSite: "strict",
+                maxAge: jwt.expiresIn
+            });
+            req.res?.cookie("rjwt", rjwt.token, {
+                httpOnly: true,
+                secure: conf.ENV === "production",
+                sameSite: "strict",
+                maxAge: rjwt.expiresIn
+            });
+            req.res?.cookie("session", rjwt.token, {
+                httpOnly: true,
+                secure: conf.ENV === "production",
+                sameSite: "strict",
+                maxAge: rjwt.expiresIn
+            });
+            return new ServerResponse(201, "Signup successful", { user });
+        }
+        catch (error) {
+            logger.error(`Signup error for email ${email}: ${error instanceof Error ? error.message : String(error)}`);
+            return new ServerResponse(400, error instanceof Error ? error.message : "Signup failed");
+        }
+    }
+    async refresh(req) {
+        try {
+            const refreshToken = req.headers.cookie?.split(';').find(cookie => cookie.trim().startsWith('rjwt='))?.split('=')[1];
+            if (!refreshToken) {
+                return new ServerResponse(401, "No refresh token provided");
+            }
+            const user = await AuthService.validateRefreshToken(refreshToken);
+            if (!user) {
+                return new ServerResponse(401, "Invalid refresh token");
+            }
+            const { jwt } = await AuthService.generateAccessToken(user.id);
+            req.res?.cookie("jwt", jwt.token, {
+                httpOnly: true,
+                secure: conf.ENV === "production",
+                sameSite: "strict",
+                maxAge: jwt.expiresIn
+            });
+            return new ServerResponse(200, "Token refreshed", { user });
+        }
+        catch (error) {
+            logger.error(`Refresh error: ${error instanceof Error ? error.message : String(error)}`);
+            return new ServerResponse(401, "Invalid refresh token");
+        }
+    }
+};
+__decorate([
+    Post("/login"),
+    __param(0, Body(undefined, new ZodValidationPipe(LoginUserSchema))),
+    __param(1, Req()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AuthController.prototype, "login", null);
+__decorate([
+    Post("/signup"),
+    __param(0, Body(undefined, new ZodValidationPipe(SignupUserSchema))),
+    __param(1, Req()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AuthController.prototype, "signup", null);
+__decorate([
+    Get("/refresh"),
+    __param(0, Req()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], AuthController.prototype, "refresh", null);
+AuthController = __decorate([
+    Controller("/auth")
+], AuthController);
+export default AuthController;

package/dist/modules/auth/auth.service.js

@@ -0,0 +1,84 @@
+import prisma from "../../common/prisma/index.js";
+import { compare, encrypt } from "../../common/util/index.js";
+import conf from "../../conf/index.js";
+import jwtoken from "jsonwebtoken";
+class AuthService {
+    static async login(email, password) {
+        const user = await prisma.user.findUnique({ where: { email } });
+        if (!user) {
+            throw new Error("User not found");
+        }
+        const isPasswordValid = compare(password, user.password);
+        if (!isPasswordValid) {
+            throw new Error("Invalid password");
+        }
+        return user;
+    }
+    static async signup(email, password, name) {
+        const existingUser = await prisma.user.findUnique({ where: { email } });
+        if (existingUser) {
+            throw new Error("Email already in use");
+        }
+        const encryptedPassword = encrypt(password);
+        const newUser = await prisma.user.create({
+            data: {
+                email,
+                password: encryptedPassword,
+                name
+            }
+        });
+        return newUser;
+    }
+    static async generateRefreshToken(userId, sessionId) {
+        const user = await prisma.user.findUnique({ where: { id: userId } });
+        if (!user) {
+            throw new Error("User not found");
+        }
+        const rjwt = jwtoken.sign({ id: user.id }, conf.JWT_SECRET, { algorithm: conf.ALGORITHM, expiresIn: conf.RJWT_EXPIRATION });
+        const rjwtObject = {
+            token: rjwt,
+            expiresIn: conf.RJWT_EXPIRATION
+        };
+        const existingSession = sessionId ? await prisma.session.findUnique({ where: { id: sessionId } }) : null;
+        if (!existingSession) {
+            await prisma.session.create({
+                data: {
+                    token: rjwt,
+                    userId: user.id,
+                    expiresAt: new Date(Date.now() + conf.RJWT_EXPIRATION)
+                }
+            });
+        }
+        else {
+            await prisma.session.update({
+                where: { id: existingSession.id },
+                data: {
+                    token: rjwt,
+                    expiresAt: new Date(Date.now() + conf.RJWT_EXPIRATION)
+                }
+            });
+        }
+        return { rjwt: rjwtObject };
+    }
+    static async generateAccessToken(userId) {
+        const user = await prisma.user.findUnique({ where: { id: userId } });
+        if (!user) {
+            throw new Error("User not found");
+        }
+        const jwt = jwtoken.sign({ id: user.id }, conf.JWT_SECRET, { algorithm: conf.ALGORITHM, expiresIn: conf.JWT_EXPIRATION });
+        const jwtObject = {
+            token: jwt,
+            expiresIn: conf.JWT_EXPIRATION
+        };
+        return { jwt: jwtObject };
+    }
+    static async validateRefreshToken(token) {
+        jwtoken.verify(token, conf.JWT_SECRET, { algorithms: [conf.ALGORITHM] });
+        const session = await prisma.session.findUnique({ where: { token }, include: { user: { omit: { password: true } } } });
+        if (!session) {
+            throw new Error("Session not found");
+        }
+        return session.user;
+    }
+}
+export { AuthService };

package/dist/modules/auth/auth.zod.schemas.js

@@ -0,0 +1,11 @@
+import z from "zod";
+const LoginUserSchema = z.object({
+    email: z.string({ error: (iss) => iss.input === undefined ? "Email is required" : iss.message }).email(),
+    password: z.string({ error: (iss) => iss.input === undefined ? "Password is required" : iss.message }).min(6)
+});
+const SignupUserSchema = z.object({
+    email: z.string({ error: (iss) => iss.input === undefined ? "Email is required" : iss.message }).email(),
+    password: z.string({ error: (iss) => iss.input === undefined ? "Password is required" : iss.message }).min(6),
+    name: z.string({ error: (iss) => iss.input === undefined ? "Name is required" : iss.message }).min(2)
+});
+export { LoginUserSchema, SignupUserSchema };

package/dist/shared/middlewares/Auth.js

@@ -0,0 +1,48 @@
+import { Middleware } from "../models/Middleware.js";
+import jwt from "jsonwebtoken";
+import conf from "../../conf/index.js";
+import { getRedisClient } from "../../common/redis/index.js";
+import { ServerResponse } from "../models/ServerResponse.js";
+import prisma from "../../common/prisma/index.js";
+const { ALGORITHM } = conf;
+/**
+ * Auth middleware to protect routes that require authentication. It checks for the presence of a JWT token in the cookies, verifies it, and attaches the authenticated user to the request context. If the token is missing, invalid, or expired, it responds with a 401 Unauthorized status.
+ */
+class Auth extends Middleware {
+    async handle(ctx) {
+        const accessToken = ctx.req.headers.cookie?.split(';').find(cookie => cookie.trim().startsWith('jwt='))?.split('=')[1];
+        if (!accessToken) {
+            ctx.res.status(401).json(new ServerResponse(401, "No token provided"));
+            return;
+        }
+        try {
+            const decoded = jwt.verify(accessToken, conf.JWT_SECRET, {
+                algorithms: [ALGORITHM]
+            });
+            const redisClient = await getRedisClient();
+            let cachedUser = null;
+            if (redisClient) {
+                cachedUser = await redisClient.get(`user:${decoded.id}`);
+            }
+            if (cachedUser) {
+                ctx.user = JSON.parse(cachedUser);
+                ctx.next();
+                return;
+            }
+            const dbUser = await prisma.user.findUnique({ where: { id: decoded.id }, omit: { password: true } });
+            if (!dbUser)
+                throw new Error("User not found");
+            if (redisClient) {
+                await redisClient.set(`user:${decoded.id}`, JSON.stringify(dbUser), { EX: 3600 });
+            }
+            ctx.user = dbUser;
+            ctx.req.user = dbUser;
+            ctx.next();
+        }
+        catch (error) {
+            const message = error.name === 'TokenExpiredError' ? 'Token Expired' : 'Unauthorized';
+            ctx.res.status(401).json(new ServerResponse(401, message));
+        }
+    }
+}
+export { Auth };