@sharangyawali/sg-app 1.0.10

package/logger/logger-service.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppLogger = void 0;
+const winston_1 = require("winston");
+class AppLogger {
+    logger;
+    constructor() {
+        const colorizer = winston_1.format.colorize();
+        (0, winston_1.addColors)({
+            info: "bold green",
+            log: "bold white",
+            warn: "bold yellow"
+        });
+        const myFormat = winston_1.format.printf(({ message }) => {
+            const coloredTime = colorizer.colorize("log", new Date().toLocaleString());
+            const coloredServer = colorizer.colorize("info", "[NODE] SGAPP");
+            return `${coloredServer}- ${coloredTime}  ${message}`;
+        });
+        this.logger = (0, winston_1.createLogger)({
+            level: "info",
+            format: winston_1.format.combine(winston_1.format.colorize({ all: true }), myFormat),
+            transports: [
+                new winston_1.transports.Console(),
+            ],
+            exitOnError: false
+        });
+    }
+    log(message) {
+        this.logger.log("info", message);
+    }
+    debug(message) {
+        this.logger.debug(message);
+    }
+    warn(message) {
+        this.logger.warn(message);
+    }
+    error(message) {
+        this.logger.error(message);
+    }
+    logWithContext(context, message) {
+        this.logger.info(`[${context}] ${message}`);
+    }
+}
+exports.AppLogger = AppLogger;

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@sharangyawali/sg-app",
+  "version": "1.0.10",
+  "keywords": [],
+  "author": "Sharan Gyawali",
+  "license": "MIT",
+  "description": "SG-APP - Express App In CLEAN ARCHITECTURE",
+  "devDependencies": {
+    "@types/express": "^5.0.6",
+    "@types/node": "^25.0.3",
+    "ts-node": "^10.9.2",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.14.3",
+    "cors": "^2.8.5",
+    "dotenv": "^17.2.3",
+    "express": "^5.2.1",
+    "reflect-metadata": "^0.2.2",
+    "winston": "^3.19.0"
+  }
+}

package/routes-config.d.ts

@@ -0,0 +1,24 @@
+import { Express } from "express";
+import { GlobalPrefixOptions } from "./common";
+export declare class RoutRegister {
+    private readonly logger;
+    private router;
+    private prefix;
+    private prefixOptions;
+    private app;
+    constructor();
+    register(app: Express, globalPrefix?: string, prefixOptions?: GlobalPrefixOptions): Promise<void>;
+    private registerCLS;
+    private registerMiddleWares;
+    private doContains;
+    private registerControllerCLasses;
+    private registerRoute;
+    private routeHandler;
+    private registerGuards;
+    private handleRequestInterceptors;
+    private handleResponseInterceptors;
+    private validateParameters;
+    private catchExceptions;
+    private reduceErrors;
+    private capitalizeFirstLetter;
+}

package/routes-config.js

@@ -0,0 +1,224 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoutRegister = void 0;
+const logger_1 = require("./logger");
+const common_1 = require("./common");
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+const cls_1 = require("./cls");
+const di_container_1 = require("./di-container");
+class RoutRegister {
+    logger;
+    router;
+    prefix;
+    prefixOptions;
+    app;
+    constructor() {
+        this.logger = new logger_1.AppLogger();
+    }
+    async register(app, globalPrefix, prefixOptions) {
+        this.app = app;
+        this.router = app.router;
+        this.prefix = globalPrefix;
+        this.prefixOptions = prefixOptions;
+        this.registerCLS();
+        this.registerMiddleWares();
+        await this.registerControllerCLasses();
+    }
+    registerCLS() {
+        di_container_1.container.register({
+            scope: common_1.Scope.SINGLETON,
+            token: cls_1.CLSService,
+            useClass: cls_1.CLSService
+        });
+    }
+    registerMiddleWares() {
+        for (const middleware of common_1.middlewares) {
+            this.app.use(async (req, res, next) => {
+                let path = req.path;
+                if (this.prefix) {
+                    const splits = path.split(`${this.prefix}`);
+                    if (splits.length > 1)
+                        path = splits[1];
+                    else
+                        path = splits[0];
+                }
+                const options = middleware.options;
+                if (options?.exclude &&
+                    options?.exclude.length > 0 &&
+                    this.doContains(options?.exclude, path, req.method)) {
+                    return next();
+                }
+                if (options?.forRoutes &&
+                    options?.forRoutes.length > 0 &&
+                    !this.doContains(options?.forRoutes, path, req.method)) {
+                    return next();
+                }
+                const middlewareInstance = await di_container_1.container.resolve(middleware.target);
+                await middlewareInstance.use(req, res, next);
+            });
+        }
+    }
+    doContains(excludes, path, method) {
+        return excludes.some((e) => path.startsWith(e.routePrefix) &&
+            (e.method === common_1.RequestMethodEnum.ALL ||
+                e.method === method.toLowerCase()));
+    }
+    async registerControllerCLasses() {
+        for (let ControllerClass of common_1.controllers) {
+            const prefix = ControllerClass.prototype.prefix;
+            for (const method of (ControllerClass.prototype
+                .methods || [])) {
+                const guards = [
+                    ...(ControllerClass.prototype[method.handler].guards || []),
+                    ...common_1.globalGuards
+                ];
+                const interceptors = [
+                    ...(ControllerClass.prototype[method.handler].interceptors || []),
+                    ...common_1.globalInterceptors
+                ];
+                const parameters = ControllerClass.prototype[method.handler].parameters || [];
+                const scope = di_container_1.container.computeEffectiveScope(ControllerClass);
+                await this.registerRoute(prefix, method, guards, interceptors, parameters, ControllerClass, scope);
+            }
+        }
+    }
+    async registerRoute(prefix, method, guards, interceptors, parameters, controllerInstance, scope) {
+        let path = method.path ? `${prefix}${method.path}` : prefix;
+        if (this.prefix &&
+            (!this.prefixOptions ||
+                !this.prefixOptions.exclude ||
+                this.prefixOptions.exclude.length <= 0 ||
+                !this.doContains(this.prefixOptions.exclude, path, method.method))) {
+            path = this.prefix + path;
+        }
+        const logString = `[ROUTE] MAPPED{${path}, ${method.method.toUpperCase()}}`;
+        if (scope == common_1.Scope.SINGLETON) {
+            controllerInstance = await di_container_1.container.resolve(controllerInstance);
+        }
+        this.router[method.method](path, async (req, res) => {
+            const cls = await di_container_1.container.resolve(cls_1.CLSService);
+            cls.run(req, async () => {
+                const httpContext = new common_1.HttpContext(req, res, method);
+                try {
+                    await this.routeHandler(req, res, guards, interceptors, httpContext, parameters, scope !== common_1.Scope.SINGLETON ? await di_container_1.container.resolve(controllerInstance, cls.get('requestId')) : controllerInstance, method);
+                }
+                catch (error) {
+                    console.log({ error });
+                    if (error instanceof common_1.HttpException) {
+                        await this.catchExceptions(httpContext, error);
+                        if (!res.headersSent)
+                            res.status(error.statusCode).json({ ...error.message });
+                    }
+                    else {
+                        if (!res.headersSent)
+                            res.status(500).json({ message: "Internal Server Error!!" });
+                    }
+                }
+                finally {
+                    di_container_1.container.removeRequest(cls.get('instanceId'));
+                }
+            });
+        });
+        this.logger.log(logString);
+    }
+    async routeHandler(req, res, guards, interceptors, httpContext, parameters, controller, method) {
+        await this.registerGuards(guards, httpContext);
+        const afterResponseInterceptor = await this.handleRequestInterceptors(interceptors, httpContext);
+        const validatedParameters = await this.validateParameters(parameters, req, res);
+        let data = await controller[method.handler](...validatedParameters);
+        data = await this.handleResponseInterceptors(afterResponseInterceptor, data);
+        if (!res.headersSent)
+            res.send(data);
+    }
+    async registerGuards(guards, httpContext) {
+        for (const guard of guards) {
+            const guardInstance = await di_container_1.container.resolve(guard);
+            const canActive = await guardInstance.canAccess(httpContext);
+            if (!canActive)
+                throw new common_1.HttpException("Forbidden", 403);
+        }
+    }
+    async handleRequestInterceptors(interceptors, httpContext) {
+        const afterInterceptors = [];
+        for (const interceptor of interceptors) {
+            let interceptorInstance;
+            if (typeof interceptor == "object")
+                interceptorInstance = interceptor;
+            else
+                interceptorInstance = await di_container_1.container.resolve(interceptor);
+            const afterIntercept = await interceptorInstance.intercept(httpContext);
+            if (afterIntercept)
+                afterInterceptors.push(afterIntercept);
+        }
+        return afterInterceptors;
+    }
+    async handleResponseInterceptors(interceptors, data) {
+        for (const afterInterceptor of interceptors) {
+            data = await afterInterceptor(data);
+        }
+        return data;
+    }
+    async validateParameters(parameters, request, response) {
+        const transformedParameters = [];
+        parameters.sort((a, b) => a.index - b.index);
+        for (const { paramType, dtoClass } of parameters) {
+            let paramData;
+            if (paramType == common_1.RequestParameters.QUERY) {
+                paramData = structuredClone(request.query);
+            }
+            else if (paramType == common_1.RequestParameters.BODY)
+                paramData = structuredClone(request.body);
+            else if (paramType == common_1.RequestParameters.PARAMS)
+                paramData = structuredClone(request.params);
+            else if (paramType == common_1.RequestParameters.FILE)
+                paramData = structuredClone(request["file"]);
+            else if (paramType == common_1.RequestParameters.FILES)
+                paramData = structuredClone(request["files"]);
+            else if (paramType == common_1.RequestParameters.REQUEST)
+                paramData = request;
+            else if (paramType == common_1.RequestParameters.RESPONSE)
+                paramData = response;
+            if (dtoClass) {
+                const transformedClass = (0, class_transformer_1.plainToInstance)(dtoClass, { ...paramData }, { enableImplicitConversion: true });
+                let errors = [];
+                if ((0, class_validator_1.getMetadataStorage)().getTargetValidationMetadatas(dtoClass, '', false, false).length > 0)
+                    errors = await (0, class_validator_1.validate)(transformedClass, {
+                        whitelist: true
+                    });
+                if (errors.length > 0) {
+                    throw new common_1.HttpException(this.reduceErrors(errors) || 'Validation error!!', 400);
+                }
+                transformedParameters.push(transformedClass);
+            }
+            else {
+                transformedParameters.push(paramData);
+            }
+        }
+        return transformedParameters;
+    }
+    async catchExceptions(httpContext, error) {
+        for (const filter of common_1.filters) {
+            const filterInstance = await di_container_1.container.resolve(filter);
+            await filterInstance.catch(error, httpContext);
+        }
+    }
+    reduceErrors(errors) {
+        return errors?.reduce((obj, item) => {
+            if (item.children?.length > 0) {
+                obj[item.property] = this.reduceErrors(item.children);
+            }
+            else {
+                obj[item.property] = this.capitalizeFirstLetter(Array.isArray(Object.values(item.constraints))
+                    ? Object.values(item.constraints)[0]
+                    : Object.values(item.constraints).toString());
+            }
+            return obj;
+        }, {});
+    }
+    capitalizeFirstLetter(string) {
+        return string.charAt(0).toUpperCase() + string.slice(1);
+    }
+    ;
+}
+exports.RoutRegister = RoutRegister;

package/set-meta-data.d.ts

@@ -0,0 +1 @@
+export declare const SetMetaData: (key: string, value: any) => MethodDecorator;

package/set-meta-data.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetMetaData = void 0;
+const SetMetaData = (key, value) => {
+    return function (target, propertyKey) {
+        if (!target.methods) {
+            target.methods = [];
+            const data = {
+                handler: propertyKey
+            };
+            data[key] = value;
+            target.methods.push(data);
+        }
+        else {
+            const newMethods = [];
+            let include = false;
+            for (const r of target.methods) {
+                if (r.handler == propertyKey) {
+                    r[key] = value;
+                    include = true;
+                }
+                newMethods.push(r);
+            }
+            if (!include) {
+                const data = {
+                    handler: propertyKey
+                };
+                data[key] = value;
+                newMethods.push(data);
+            }
+            target.methods = newMethods;
+        }
+    };
+};
+exports.SetMetaData = SetMetaData;

package/sg-application.d.ts

@@ -0,0 +1,12 @@
+import { Express } from "express";
+import { GlobalPrefixOptions, ISGApplication, StaticRoutes } from ".";
+export declare class SGApplication implements ISGApplication {
+    private app;
+    private prefixOptions;
+    private prefix;
+    constructor(app: Express);
+    use(...args: any[]): this;
+    setStaticRoutes(options: StaticRoutes[]): this;
+    setGlobalPrefix(prefix: string, options?: GlobalPrefixOptions): this;
+    listen(port: number, callback?: (error?: Error) => void): Promise<any>;
+}

package/sg-application.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SGApplication = void 0;
+const _1 = require(".");
+const express_1 = __importDefault(require("express"));
+class SGApplication {
+    app;
+    prefixOptions;
+    prefix;
+    constructor(app) {
+        this.app = app;
+    }
+    use(...args) {
+        this.app.use(...args);
+        return this;
+    }
+    setStaticRoutes(options) {
+        options.forEach((o) => {
+            o.prefix ? this.app.use(o.prefix, express_1.default.static(o.path, { ...(o.options) })) : this.app.use(express_1.default.static(o.path, { ...(o.options) }));
+        });
+        return this;
+    }
+    setGlobalPrefix(prefix, options) {
+        this.prefix = prefix;
+        if (options)
+            this.prefixOptions = options;
+        return this;
+    }
+    async listen(port, callback) {
+        await new _1.RoutRegister().register(this.app, this.prefix, this.prefixOptions);
+        return this.app.listen(port, callback);
+    }
+}
+exports.SGApplication = SGApplication;

package/sg-factory.d.ts

@@ -0,0 +1,7 @@
+import { FactoryOptions, ISGApplication, ISGFactory } from ".";
+export declare class SGFactory implements ISGFactory {
+    private app;
+    constructor();
+    create(_: any, options?: FactoryOptions): ISGApplication;
+    private registerClasses;
+}

package/sg-factory.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SGFactory = void 0;
+const express_1 = __importDefault(require("express"));
+const _1 = require(".");
+const cors_1 = __importDefault(require("cors"));
+class SGFactory {
+    app;
+    constructor() {
+        this.registerClasses();
+    }
+    create(_, options) {
+        this.app = (0, express_1.default)();
+        this.app.use(express_1.default.json());
+        this.app.use(express_1.default.urlencoded({ extended: true }));
+        if (options && options.cors)
+            typeof options.cors === 'boolean' ? this.app.use((0, cors_1.default)()) : this.app.use((0, cors_1.default)({ ...options.cors }));
+        return new _1.SGApplication(this.app);
+    }
+    registerClasses() {
+        _1.container.register({
+            scope: _1.Scope.SINGLETON,
+            token: _1.ConfigService,
+            useClass: _1.ConfigService
+        });
+        _1.container.register({
+            scope: _1.Scope.SINGLETON,
+            token: _1.AppLogger,
+            useClass: _1.AppLogger
+        });
+    }
+}
+exports.SGFactory = SGFactory;