@sharangyawali/sg-app 0.0.5

package/routes-config.d.ts

@@ -0,0 +1,22 @@
+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 registerClasses;
+    private registerMiddleWares;
+    private doContains;
+    private registerControllerCLasses;
+    private registerRoute;
+    private routeHandler;
+    private registerGuards;
+    private handleRequestInterceptors;
+    private handleResponseInterceptors;
+    private validateParameters;
+    private catchExceptions;
+}

package/routes-config.js

@@ -0,0 +1,204 @@
+"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 config_1 = require("./config");
+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.registerClasses();
+        this.registerMiddleWares();
+        this.registerControllerCLasses();
+    }
+    registerClasses() {
+        di_container_1.container.register({
+            scope: common_1.Scope.SINGLETON,
+            token: config_1.ConfigService,
+            useClass: config_1.ConfigService
+        });
+        di_container_1.container.register({
+            scope: common_1.Scope.SINGLETON,
+            token: logger_1.AppLogger,
+            useClass: logger_1.AppLogger
+        });
+        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 = 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()));
+    }
+    registerControllerCLasses() {
+        for (const 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 || [];
+                this.registerRoute(prefix, method, guards, interceptors, parameters, ControllerClass);
+            }
+        }
+    }
+    registerRoute(prefix, method, guards, interceptors, parameters, controller) {
+        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()}}`;
+        this.router[method.method](path, async (req, res) => {
+            const cls = di_container_1.container.resolve(cls_1.CLSService);
+            cls.run(req, async () => {
+                const httpContext = new common_1.HttpContext(req, res, method);
+                const controllerInstance = di_container_1.container.resolve(controller);
+                try {
+                    await this.routeHandler(req, res, guards, interceptors, httpContext, parameters, controllerInstance, method);
+                }
+                catch (error) {
+                    console.log({ error });
+                    if (error instanceof common_1.HttpException) {
+                        await this.catchExceptions(httpContext, error);
+                    }
+                    else
+                        res.status(500).json({ message: "Internal Server Error!!" });
+                }
+                finally {
+                    di_container_1.container.removeRequestInstances(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);
+        let data = await controller[method.handler](...validatedParameters);
+        data = await this.handleResponseInterceptors(afterResponseInterceptor, data);
+        res.send(data);
+    }
+    async registerGuards(guards, httpContext) {
+        for (const guard of guards) {
+            const guardInstance = 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 = 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) {
+        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"]);
+            if (dtoClass) {
+                const transformedClass = (0, class_transformer_1.plainToInstance)(dtoClass, { ...paramData }, { enableImplicitConversion: true });
+                const errors = await (0, class_validator_1.validate)(transformedClass, {
+                    whitelist: true
+                });
+                if (errors.length > 0) {
+                    throw new common_1.HttpException(errors, 400);
+                }
+                transformedParameters.push(transformedClass);
+            }
+            else {
+                transformedParameters.push(paramData);
+            }
+        }
+        return transformedParameters;
+    }
+    async catchExceptions(httpContext, error) {
+        for (const filter of common_1.filters) {
+            const filterInstance = di_container_1.container.resolve(filter);
+            await filterInstance.catch(error, httpContext);
+        }
+    }
+}
+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) {
+        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,6 @@
+import { FactoryOptions, ISGApplication, ISGFactory } from ".";
+export declare class SGFactory implements ISGFactory {
+    private app;
+    constructor();
+    create(_: any, options?: FactoryOptions): ISGApplication;
+}

package/sg-factory.js

@@ -0,0 +1,22 @@
+"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() { }
+    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);
+    }
+}
+exports.SGFactory = SGFactory;

package/src/cls/cls.service.ts

@@ -0,0 +1,31 @@
+import { AsyncLocalStorage } from "async_hooks";
+import crypto from "crypto";
+import { Request, Response } from "express";
+
+export class CLSService {
+  private readonly asyncLocalStorage: AsyncLocalStorage<any>;
+  constructor() {
+    this.asyncLocalStorage = new AsyncLocalStorage();
+  }
+
+  run(req: Request, fn: () => Promise<any> | any) {
+    const requestId = crypto.randomUUID();
+    return this.asyncLocalStorage.run({ requestId, request: req }, fn);
+  }
+
+  set(key: string, value: any): void {
+    const store = this.asyncLocalStorage.getStore();
+    if (!store) {
+      throw new Error("CLS context not initialized");
+    }
+    store[key] = value;
+  }
+
+  get<T = any>(key: string): T {
+    const store = this.asyncLocalStorage.getStore();
+    if (!store) {
+      throw new Error("CLS context not initialized");
+    }
+    return store[key];
+  }
+}

package/src/cls/index.ts

@@ -0,0 +1 @@
+export * from "./cls.service";

package/src/common/constants/index.ts

@@ -0,0 +1 @@
+export * from "./providers.constants";

package/src/common/constants/providers.constants.ts

@@ -0,0 +1 @@
+export const REQUEST = "request";

package/src/common/decorators/component.decorators.ts

@@ -0,0 +1,13 @@
+import { container } from "../../di-container";
+import { Scope } from "../enum";
+import { InjectableOptions } from "../interface";
+
+export function Component(options?: InjectableOptions): ClassDecorator {
+  return function (target: any) {
+    container.register({
+      token: options && options.token ? options.token : target,
+      useClass: target as any,
+      scope: options && options.scope ? options.scope : Scope.SINGLETON
+    });
+  };
+}

package/src/common/decorators/controller.decorator.ts

@@ -0,0 +1,16 @@
+import { container } from "../../di-container";
+import { Scope } from "../enum";
+
+export const controllers: any[] = [];
+
+export function RestController(prefix: string = "/"): ClassDecorator {
+  return function (target: any) {
+    target.prototype.prefix = prefix[0] !== "/" ? "/" + prefix : prefix;
+    controllers.push(target);
+    container.register({
+      token: target,
+      useClass: target as any,
+      scope: Scope.SINGLETON
+    });
+  };
+}

package/src/common/decorators/filters.decorator.ts

@@ -0,0 +1,17 @@
+import { container } from "../../di-container";
+import { Scope } from "../enum";
+
+export const filters: any[] = [];
+
+export function Catch(): ClassDecorator {
+  return function (target: any) {
+    if (typeof target.prototype.catch !== "function")
+      throw new Error(`${target.name} does not implements catch method`);
+    filters.push(target);
+    container.register({
+      token: target,
+      useClass: target as any,
+      scope: Scope.SINGLETON
+    });
+  };
+}

package/src/common/decorators/guards.decorator.ts

@@ -0,0 +1,26 @@
+import { SGGuard } from "../interface";
+import { container } from "../../di-container";
+import { Scope } from "../enum";
+
+export const globalGuards: any[] = [];
+
+export function UseGuard(
+  ...guardClasses: (SGGuard | Function)[]
+): MethodDecorator {
+  return function (target: any, propertyKey: string | symbol) {
+    target[propertyKey].guards = guardClasses;
+  };
+}
+
+export function GlobalGuard(): ClassDecorator {
+  return function (target: any) {
+    if (typeof target.prototype.canAccess !== "function")
+      throw new Error(`${target.name} does not implements canActivate method`);
+    globalGuards.push(target);
+    container.register({
+      token: target,
+      useClass: target as any,
+      scope: Scope.SINGLETON
+    });
+  };
+}

package/src/common/decorators/index.ts

@@ -0,0 +1,10 @@
+export * from "./controller.decorator";
+export * from "./filters.decorator";
+export * from "./guards.decorator";
+export * from "./interceptors.decorator";
+export * from "./middlewares.decorator";
+export * from "./parameter-validator.decorator";
+export * from "./route-mapping.decorator";
+export * from "./module.decorator";
+export * from "./component.decorators";
+export * from "./inject.decorators";

package/src/common/decorators/inject.decorators.ts

@@ -0,0 +1,12 @@
+import { Token } from "../interface";
+import "reflect-metadata";
+export function Inject(token: Token): ParameterDecorator & PropertyDecorator {
+  return (target: any, _: string | symbol | undefined, index?: number) => {
+    if (typeof index === "number") {
+      const existing =
+        Reflect.getMetadata("custom:inject_tokens", target) || {};
+      existing[index] = token;
+      Reflect.defineMetadata("custom:inject_tokens", existing, target);
+    }
+  };
+}

package/src/common/decorators/interceptors.decorator.ts

@@ -0,0 +1,26 @@
+import { SGInterceptor } from "../interface";
+import { container } from "../../di-container";
+import { Scope } from "../enum";
+
+export const globalInterceptors: any[] = [];
+
+export function UseInterceptor(
+  ...interceptorClasses: (SGInterceptor | Function)[]
+): MethodDecorator {
+  return function (target: any, propertyKey: string | symbol) {
+    target[propertyKey].interceptors = interceptorClasses;
+  };
+}
+
+export function GlobalInterceptors(): ClassDecorator {
+  return function (target: any) {
+    if (typeof target.prototype.intercept !== "function")
+      throw new Error(`${target.name} does not implements intercept method`);
+    globalInterceptors.push(target);
+    container.register({
+      token: target,
+      useClass: target as any,
+      scope: Scope.SINGLETON
+    });
+  };
+}

package/src/common/decorators/middlewares.decorator.ts

@@ -0,0 +1,18 @@
+import { container } from "../../di-container";
+import { Scope } from "../enum/scope.enum";
+import { MiddlewareOptions } from "../interface/global-middleware-options.interface";
+
+export const middlewares: any[] = [];
+
+export function Middleware(options?: MiddlewareOptions): ClassDecorator {
+  return function (target: any) {
+    if (typeof target.prototype.use !== "function")
+      throw new Error(`${target.name} does not implements use method`);
+    middlewares.push({ target, options });
+    container.register({
+      token: target,
+      useClass: target as any,
+      scope: Scope.SINGLETON
+    });
+  };
+}

package/src/common/decorators/module.decorator.ts

@@ -0,0 +1,29 @@
+import { container } from "../../di-container";
+import { Scope } from "../enum";
+import { ModuleOptions, Provider } from "../interface";
+
+export function Module(options?: ModuleOptions): ClassDecorator {
+  return function (target: any) {
+    if (options.providers) {
+      options.providers.forEach((p) => {
+        if (Object.keys(p).length > 0) {
+          const provider = p as Provider;
+          container.register({
+            scope: provider.scope || Scope.SINGLETON,
+            token: provider.token,
+            useValue: provider.useValue,
+            useClass: provider.useClass,
+            useFactory: provider.useFactory,
+            inject: provider.inject
+          });
+        } else {
+          container.register({
+            scope: Scope.SINGLETON,
+            token: p as any,
+            useClass: p as any
+          });
+        }
+      });
+    }
+  };
+}

package/src/common/decorators/parameter-validator.decorator.ts

@@ -0,0 +1,17 @@
+import { RequestParameters } from "../enum";
+import { ControllerMethodParams } from "../interface";
+
+function Validator(data: string, dtoClass: any): ParameterDecorator {
+  return function (target: any, propertyKey: string | symbol, index: number) {
+    const parameters: ControllerMethodParams[] =
+      target[propertyKey].parameters || [];
+    parameters.push({ index, dtoClass, paramType: data });
+    target[propertyKey].parameters = parameters;
+  };
+}
+
+export const Query = (dtoClass: any) => Validator(RequestParameters.QUERY, dtoClass);
+export const Body = (dtoClass: any) => Validator(RequestParameters.BODY, dtoClass);
+export const Params = (dtoClass: any) => Validator(RequestParameters.PARAMS, dtoClass);
+export const UploadedFile = () => Validator(RequestParameters.FILE, null)
+export const UploadedFiles = () => Validator(RequestParameters.FILES, null)

package/src/common/decorators/route-mapping.decorator.ts

@@ -0,0 +1,27 @@
+import { ControllerMethods } from "../interface";
+
+function RequestMapping(method: string, path?: string): MethodDecorator {
+  return function (target: any, propertyKey: string | symbol) {
+    const methods: ControllerMethods[] = target.methods || [];
+    const index = methods.findIndex((m) => m.handler === propertyKey);
+    if (index > -1)
+      methods[index] = {
+        ...methods[index],
+        method: method,
+        path: path && path.length > 0 && path[0] !== "/" ? "/" + path : path
+      };
+    else
+      methods.push({
+        handler: propertyKey,
+        method,
+        path: path && path.length > 0 && path[0] !== "/" ? "/" + path : path
+      });
+    target.methods = methods;
+  };
+}
+
+export const Get = (path?: string) => RequestMapping("get", path);
+export const Post = (path?: string) => RequestMapping("post", path);
+export const Put = (path?: string) => RequestMapping("put", path);
+export const Patch = (path?: string) => RequestMapping("patch", path);
+export const Delete = (path?: string) => RequestMapping("delete", path);

package/src/common/enum/index.ts

@@ -0,0 +1,3 @@
+export * from "./request-method.enum";
+export * from "./request-parameters.enum";
+export * from "./scope.enum";

package/src/common/enum/request-method.enum.ts

@@ -0,0 +1,11 @@
+export enum RequestMethodEnum {
+  POST = "post",
+  GET = "get",
+  DELETE = "delete",
+  PUT = "put",
+  PATCH = "patch",
+  ALL = "all",
+  OPTIONS = "options",
+  HEAD = "head",
+  SEARCH = "search"
+}

package/src/common/enum/request-parameters.enum.ts

@@ -0,0 +1,7 @@
+export enum RequestParameters {
+  QUERY = "query",
+  BODY = "body",
+  PARAMS = "params",
+  FILE = 'file',
+  FILES = 'files'
+}

package/src/common/enum/scope.enum.ts

@@ -0,0 +1,5 @@
+export enum Scope {
+  SINGLETON = "singleton",
+  TRANSIENT = "transient",
+  REQUEST = "request"
+}