@sharangyawali/sg-app 0.0.5

package/src/routes-config.ts

@@ -0,0 +1,305 @@
+import { Express, Request, Response, Router } from "express";
+import { AppLogger } from "./logger";
+import {
+  ControllerMethodParams,
+  ControllerMethods,
+  controllers,
+  filters,
+  globalGuards,
+  globalInterceptors,
+  GlobalPrefixOptions,
+  HttpContext,
+  HttpException,
+  MiddlewareOptions,
+  middlewares,
+  REQUEST,
+  RequestMethodEnum,
+  RequestParameters,
+  RouteInfo,
+  Scope,
+  SGFilter,
+  SGGuard,
+  SGInterceptor,
+  SGMiddleware
+} from "./common";
+import { plainToInstance } from "class-transformer";
+import { validate } from "class-validator";
+import { CLSService } from "./cls";
+import { ConfigService } from "./config";
+import { container } from "./di-container";
+
+export class RoutRegister {
+  private readonly logger: AppLogger;
+  private router: Router;
+  private prefix: string;
+  private prefixOptions: GlobalPrefixOptions;
+  private app: Express;
+  constructor() {
+    this.logger = new AppLogger();
+  }
+
+  async register(
+    app: Express,
+    globalPrefix?: string,
+    prefixOptions?: GlobalPrefixOptions
+  ) {
+    this.app = app;
+    this.router = app.router;
+    this.prefix = globalPrefix;
+    this.prefixOptions = prefixOptions;
+    this.registerClasses();
+    this.registerMiddleWares();
+    this.registerControllerCLasses();
+  }
+  private registerClasses() {
+    container.register({
+      scope: Scope.SINGLETON,
+      token: ConfigService,
+      useClass: ConfigService
+    });
+    container.register({
+      scope: Scope.SINGLETON,
+      token: AppLogger,
+      useClass: AppLogger
+    });
+    container.register({
+      scope: Scope.SINGLETON,
+      token: CLSService,
+      useClass: CLSService
+    });
+  }
+
+  private registerMiddleWares() {
+    for (const middleware of 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: MiddlewareOptions = 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 = container.resolve<SGMiddleware>(
+          middleware.target
+        );
+        await middlewareInstance.use(req, res, next);
+      });
+    }
+  }
+
+  private doContains(
+    excludes: RouteInfo[],
+    path: string,
+    method: string
+  ): Boolean {
+    return excludes.some(
+      (e) =>
+        path.startsWith(e.routePrefix) &&
+        (e.method === RequestMethodEnum.ALL ||
+          e.method === method.toLowerCase())
+    );
+  }
+
+  private registerControllerCLasses() {
+    for (const ControllerClass of controllers) {
+      const prefix = ControllerClass.prototype.prefix;
+      for (const method of ControllerClass.prototype
+        .methods as ControllerMethods[]) {
+        const guards: any[] = [
+          ...(ControllerClass.prototype[method.handler].guards || []),
+          ...globalGuards
+        ];
+        const interceptors: any[] = [
+          ...(ControllerClass.prototype[method.handler].interceptors || []),
+          ...globalInterceptors
+        ];
+        const parameters: ControllerMethodParams[] =
+          ControllerClass.prototype[method.handler].parameters || [];
+        this.registerRoute(
+          prefix,
+          method,
+          guards,
+          interceptors,
+          parameters,
+          ControllerClass
+        );
+      }
+    }
+  }
+
+  private registerRoute(
+    prefix: string,
+    method: ControllerMethods,
+    guards: any[],
+    interceptors: any[],
+    parameters: ControllerMethodParams[],
+    controller: any
+  ) {
+    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: Request, res: Response) => {
+      const cls = container.resolve(CLSService);
+      cls.run(req, async () => {
+        const httpContext = new HttpContext(req, res, method);
+        const controllerInstance = container.resolve<any>(
+          controller,
+        );
+        try {
+          await this.routeHandler(
+            req,
+            res,
+            guards,
+            interceptors,
+            httpContext,
+            parameters,
+            controllerInstance,
+            method
+          );
+        } catch (error) {
+          console.log({ error });
+          if (error instanceof HttpException) {
+            await this.catchExceptions(httpContext, error);
+          } else res.status(500).json({ message: "Internal Server Error!!" });
+        }
+        finally {
+          container.removeRequestInstances(cls.get('instanceId'))
+        }
+      });
+    });
+    this.logger.log(logString);
+  }
+
+  private async routeHandler(
+    req: Request,
+    res: Response,
+    guards: any[],
+    interceptors: any[],
+    httpContext: HttpContext,
+    parameters: any[],
+    controller: any,
+    method: ControllerMethods
+  ) {
+    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);
+  }
+  private async registerGuards(
+    guards: any[],
+    httpContext: HttpContext,
+  ) {
+    for (const guard of guards) {
+      const guardInstance = container.resolve<SGGuard>(guard);
+      const canActive = await guardInstance.canAccess(httpContext);
+      if (!canActive) throw new HttpException("Forbidden", 403);
+    }
+  }
+
+  private async handleRequestInterceptors(
+    interceptors: any[],
+    httpContext: HttpContext
+  ): Promise<((data: any) => any)[]> {
+    const afterInterceptors: ((data: any) => any)[] = [];
+    for (const interceptor of interceptors) {
+      let interceptorInstance;
+      if (typeof interceptor == "object") interceptorInstance = interceptor;
+      else
+        interceptorInstance = container.resolve<SGInterceptor>(interceptor);
+      const afterIntercept = await interceptorInstance.intercept(httpContext);
+      if (afterIntercept) afterInterceptors.push(afterIntercept);
+    }
+    return afterInterceptors;
+  }
+
+  private async handleResponseInterceptors(
+    interceptors: ((data: any) => any)[],
+    data: any
+  ): Promise<any> {
+    for (const afterInterceptor of interceptors) {
+      data = await afterInterceptor(data);
+    }
+    return data;
+  }
+
+  private async validateParameters(
+    parameters: ControllerMethodParams[],
+    request: Request
+  ): Promise<any[]> {
+    const transformedParameters = [];
+    parameters.sort((a, b) => a.index - b.index);
+    for (const { paramType, dtoClass } of parameters) {
+      let paramData;
+      if (paramType == RequestParameters.QUERY) {
+        paramData = structuredClone(request.query);
+      } else if (paramType == RequestParameters.BODY)
+        paramData = structuredClone(request.body);
+      else if (paramType == RequestParameters.PARAMS)
+        paramData = structuredClone(request.params);
+      else if (paramType == RequestParameters.FILE)
+        paramData = structuredClone(request["file"]);
+      else if (paramType == RequestParameters.FILES)
+        paramData = structuredClone(request["files"]);
+      if (dtoClass) {
+        const transformedClass = plainToInstance(
+          dtoClass,
+          { ...paramData },
+          { enableImplicitConversion: true }
+        );
+        const errors = await validate(transformedClass, {
+          whitelist: true
+        });
+        if (errors.length > 0) {
+          throw new HttpException(errors, 400);
+        }
+        transformedParameters.push(transformedClass);
+      } else {
+        transformedParameters.push(paramData);
+      }
+    }
+    return transformedParameters;
+  }
+
+  private async catchExceptions(
+    httpContext: HttpContext,
+    error: HttpException
+  ) {
+    for (const filter of filters) {
+      const filterInstance = container.resolve<SGFilter>(filter);
+      await filterInstance.catch(error, httpContext);
+    }
+  }
+}

package/src/set-meta-data.ts

@@ -0,0 +1,30 @@
+export const SetMetaData = (key: string, value: any): MethodDecorator => {
+  return function (target: any, propertyKey: string | symbol) {
+    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;
+    }
+  };
+};

package/src/sg-application.ts

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

package/src/sg-factory.ts

@@ -0,0 +1,15 @@
+import express from "express";
+import { FactoryOptions, ISGApplication, ISGFactory, SGApplication } from ".";
+import cors from 'cors';
+export class SGFactory implements ISGFactory {
+  private app;
+  constructor() { }
+  create(_: any, options?: FactoryOptions): ISGApplication {
+    this.app = express();
+    this.app.use(express.json())
+    this.app.use(express.urlencoded({ extended: true }))
+    if (options && options.cors)
+      typeof options.cors === 'boolean' ? this.app.use(cors()) : this.app.use(cors({ ...options.cors }))
+    return new SGApplication(this.app);
+  }
+}

package/tsconfig.json

@@ -0,0 +1,31 @@
+{
+  "compilerOptions": {
+    "target": "es2023",
+    "module": "commonjs",
+    "noEmit": false,
+    "allowArbitraryExtensions": true,
+    "rootDir": "./src",
+    "outDir": "./",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": false,
+    "resolveJsonModule": true,
+    "strictPropertyInitialization": false,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "declaration": true,
+    "allowSyntheticDefaultImports": true,
+    "baseUrl": "./",
+    "paths": {
+      "*": ["src/*"]
+    },
+    "incremental": true,
+    "strictNullChecks": false,
+    "noImplicitAny": false,
+    "strictBindCallApply": false,
+    "noFallthroughCasesInSwitch": false
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist"]
+}