@sharangyawali/sg-app 0.0.5

package/src/common/http/http-context.ts

@@ -0,0 +1,25 @@
+import { Request, Response } from "express";
+import { ControllerMethods } from "../interface";
+
+export class HttpContext {
+  private readonly req: Request;
+  private readonly res: Response;
+  constructor(
+    private readonly request: Request,
+    private readonly response: Response,
+    private readonly methodMeta: ControllerMethods
+  ) {
+    this.req = request;
+    this.res = response;
+  }
+
+  getRequest(): Request {
+    return this.req;
+  }
+  getResponse(): Response {
+    return this.res;
+  }
+  getMetaData<T>(key: string): T {
+    return this.methodMeta[key];
+  }
+}

package/src/common/http/http-exception.ts

@@ -0,0 +1,12 @@
+export class HttpException extends Error {
+  public readonly message: any;
+  public readonly statusCode: number;
+  constructor(
+    private readonly msg: any = "Internal Server Error",
+    private readonly status: number = 500
+  ) {
+    super(msg);
+    this.message = msg;
+    this.statusCode = status;
+  }
+}

package/src/common/http/index.ts

@@ -0,0 +1,2 @@
+export * from "./http-context";
+export * from "./http-exception";

package/src/common/index.ts

@@ -0,0 +1,5 @@
+export * from "./decorators";
+export * from "./enum";
+export * from "./interface";
+export * from "./http";
+export * from "./constants";

package/src/common/interface/controller-method-paramenters.interface.ts

@@ -0,0 +1,7 @@
+import { RequestParameters } from "../enum";
+
+export interface ControllerMethodParams<T = RequestParameters | string> {
+  dtoClass: any;
+  index: number;
+  paramType: T;
+}

package/src/common/interface/controller-methods.interface.ts

@@ -0,0 +1,7 @@
+import { RequestMethodEnum } from "../enum";
+
+export interface ControllerMethods<T = RequestMethodEnum | string> {
+  method: T;
+  path?: string;
+  handler: string | symbol;
+}

package/src/common/interface/cors.interface.ts

@@ -0,0 +1,15 @@
+export interface CorsOptions {
+    origin?: boolean | string | RegExp | (string | RegExp)[] | CorsOptionsDelegate;
+    methods?: string | string[];
+    allowedHeaders?: string | string[];
+    exposedHeaders?: string | string[];
+    credentials?: boolean;
+    preflightContinue?: boolean;
+    optionsSuccessStatus?: number;
+    maxAge?: number;
+    vary?: boolean;
+}
+
+export interface CorsOptionsDelegate {
+    (origin: string | undefined, callback: (err: Error | null, allow: boolean) => void): void;
+}

package/src/common/interface/features/index.ts

@@ -0,0 +1,4 @@
+export * from "./sg-middleware.interface";
+export * from "./sg-guard.interface";
+export * from "./sg-interceptor.interface";
+export * from "./sg-filter.interface";

package/src/common/interface/features/sg-filter.interface.ts

@@ -0,0 +1,5 @@
+import { HttpContext, HttpException } from "../..";
+
+export interface SGFilter {
+  catch(exception: HttpException, context: HttpContext): any;
+}

package/src/common/interface/features/sg-guard.interface.ts

@@ -0,0 +1,5 @@
+import { HttpContext } from "../..";
+
+export interface SGGuard {
+  canAccess(httpContext: HttpContext): Promise<Boolean>;
+}

package/src/common/interface/features/sg-interceptor.interface.ts

@@ -0,0 +1,5 @@
+import { HttpContext } from "../..";
+
+export interface SGInterceptor {
+  intercept(httpContext: HttpContext): Promise<(data: any) => any | void>;
+}

package/src/common/interface/features/sg-middleware.interface.ts

@@ -0,0 +1,5 @@
+import { NextFunction, Request, Response } from "express";
+
+export interface SGMiddleware {
+  use(request: Request, response: Response, next: NextFunction): any;
+}

package/src/common/interface/global-middleware-options.interface.ts

@@ -0,0 +1,7 @@
+import { RouteInfo } from "./route-info.interface";
+
+export interface MiddlewareOptions<T = RouteInfo> {
+  exclude?: T[];
+
+  forRoutes?: T[];
+}

package/src/common/interface/global-prefix-options.interface.ts

@@ -0,0 +1,5 @@
+import { RouteInfo } from "./route-info.interface";
+
+export interface GlobalPrefixOptions<T = RouteInfo> {
+  exclude?: T[];
+}

package/src/common/interface/index.ts

@@ -0,0 +1,15 @@
+export * from "./route-info.interface";
+export * from "./global-prefix-options.interface";
+export * from "./sg-application.interface";
+export * from "./global-middleware-options.interface";
+export * from "./features";
+export * from "./controller-methods.interface";
+export * from "./controller-method-paramenters.interface";
+export * from "./module-options.interface";
+export * from "./injectable-options.interface";
+export * from "./type.interface";
+export * from "./injection-token.interface";
+export * from "./provider.interface";
+export * from './sg-factory.interface';
+export * from './cors.interface';
+export * from './static-route.interface';

package/src/common/interface/injectable-options.interface.ts

@@ -0,0 +1,6 @@
+import { Scope } from "../enum";
+
+export interface InjectableOptions<T = Scope> {
+  scope: T;
+  token?: string;
+}

package/src/common/interface/injection-token.interface.ts

@@ -0,0 +1,2 @@
+export type Constructor<T = any> = new (...args: any[]) => T;
+export type Token<T = any> = (new (...args: any[]) => T) | symbol | string;

package/src/common/interface/module-options.interface.ts

@@ -0,0 +1,7 @@
+import { ModuleProvider } from "./provider.interface";
+
+export interface ModuleOptions {
+  controllers?: any[];
+  imports?: any[];
+  providers?: ModuleProvider[];
+}

package/src/common/interface/provider.interface.ts

@@ -0,0 +1,36 @@
+import { Scope } from "../enum";
+import { Constructor, Token } from "./injection-token.interface";
+import { Type } from "./type.interface";
+
+export type ModuleProvider<T = any> =
+  | Type<any>
+  | ClassProvider<T>
+  | ValueProvider<T>
+  | FactoryProvider<T>;
+
+export interface ClassProvider<T = any> {
+  token: Token<T>;
+  useClass?: Constructor<T>;
+  scope: Scope;
+}
+
+export interface ValueProvider<T = any> {
+  token: Token<T>;
+  useValue?: T;
+  scope: Scope;
+}
+
+export interface FactoryProvider<T = any> {
+  inject: Token[];
+  token: Token<T>;
+  useFactory: (...args: any[]) => { value: T };
+  scope: Scope;
+}
+export interface Provider<T = any> {
+  token: Token<T>;
+  useClass?: Constructor<T>;
+  useValue?: T;
+  scope: Scope;
+  inject?: Token[];
+  useFactory?: (...args: any[]) => T;
+}

package/src/common/interface/route-info.interface.ts

@@ -0,0 +1,6 @@
+import { RequestMethodEnum } from "../enum/request-method.enum";
+
+export interface RouteInfo {
+  routePrefix: string;
+  method: RequestMethodEnum;
+}

package/src/common/interface/sg-application.interface.ts

@@ -0,0 +1,9 @@
+import { GlobalPrefixOptions } from "./global-prefix-options.interface";
+import { StaticRoutes } from "./static-route.interface";
+
+export interface ISGApplication {
+  use(...args: any[]): this;
+  setStaticRoutes(options: StaticRoutes[]): this;
+  setGlobalPrefix(prefix: string, options?: GlobalPrefixOptions): this;
+  listen(port: number, callback?: (error?: Error) => void): Promise<any>;
+}

package/src/common/interface/sg-factory.interface.ts

@@ -0,0 +1,10 @@
+import { CorsOptions } from "./cors.interface";
+import { ISGApplication } from "./sg-application.interface";
+
+export interface FactoryOptions {
+    cors?: CorsOptions | boolean
+}
+
+export interface ISGFactory {
+    create(appModule: any, options?: FactoryOptions): ISGApplication
+}

package/src/common/interface/sg-interceptor.interface.ts

@@ -0,0 +1,3 @@
+export interface SGInterceptor {
+  intercepts;
+}

package/src/common/interface/static-route.interface.ts

@@ -0,0 +1,22 @@
+import { Response } from "express";
+
+export interface StaticRoutes {
+    prefix?: string;
+    path: string;
+    options?: StaticOptions
+}
+
+export interface StaticOptions<T = Response> {
+    acceptRanges?: boolean | undefined;
+    cacheControl?: boolean | undefined;
+    dotfiles?: string | undefined;
+    etag?: boolean | undefined;
+    extensions?: string[] | false | undefined;
+    fallthrough?: boolean | undefined;
+    immutable?: boolean | undefined;
+    index?: boolean | string | string[] | undefined;
+    lastModified?: boolean | undefined;
+    maxAge?: number | string | undefined;
+    redirect?: boolean | undefined;
+    setHeaders?: ((res: T, path: string, stat: any) => any) | undefined;
+}

package/src/common/interface/type.interface.ts

@@ -0,0 +1,3 @@
+export interface Type<T = any> extends Function {
+  new (...args: any[]): T;
+}

package/src/config/config-service.ts

@@ -0,0 +1,7 @@
+import { config } from 'dotenv';
+config();
+export class ConfigService {
+  get(propertyPath: string): string {
+    return process.env[propertyPath];
+  }
+}

package/src/config/index.ts

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

package/src/di-container.ts

@@ -0,0 +1,135 @@
+import {
+  Constructor,
+  HttpException,
+  Provider,
+  REQUEST,
+  Scope,
+  Token
+} from "./common";
+import { CLSService } from "./cls";
+import "reflect-metadata";
+
+class Container {
+  private providers = new Map<Token, Provider>();
+  private singletons = new Map<Token, any>();
+  private requestCache = new Map<string, Map<Token, any>>();
+
+  register(provider: Provider) {
+    this.providers.set(provider.token, provider);
+  }
+
+  resolve<T>(token: Token<T>, requestId?: string): T {
+    if (token === REQUEST) {
+      const cls = this.resolve(CLSService);
+      return cls.get("request") as T;
+    }
+
+    const provider = this.providers.get(token);
+    if (!provider) {
+      if (typeof token === "function") {
+        return this.construct(token, requestId);
+      }
+      throw new HttpException(
+        `No provider found for token: ${token.toString()}`
+      );
+    }
+    if (provider.useValue) return provider.useValue;
+
+    if (provider.scope == Scope.SINGLETON) {
+      if (!this.singletons.has(token)) {
+        const instance = provider.useFactory
+          ? this.constructFactory(provider, requestId)
+          : this.construct(provider.useClass!, requestId);
+        this.singletons.set(token, instance);
+      }
+      return this.singletons.get(token);
+    }
+
+    else if (provider.scope === Scope.REQUEST) {
+      if (!requestId) {
+        throw new Error(`Request-scoped provider "${String(token)}" needs requestId`);
+      }
+      let cache = this.requestCache.get(requestId);
+      if (!cache) {
+        cache = new Map();
+        this.requestCache.set(requestId, cache);
+      }
+      if (cache.has(token)) return cache.get(token);
+
+      const instance = provider.useFactory
+        ? this.constructFactory(provider, requestId)
+        : this.construct(provider.useClass!, requestId);
+
+      cache.set(token, instance);
+      return instance;
+    }
+    return provider.useFactory ? this.constructFactory(provider, requestId) : this.construct(provider.useClass!, requestId)
+  }
+
+  private constructFactory<T>(
+    provider: Provider<T>,
+    requestId?: string
+  ): T {
+    const params =
+      provider.inject?.map((token) => {
+        const dep = this.providers.get(token);
+
+        if (dep?.scope === Scope.REQUEST) {
+          return this.createRequestScopedProxy(token);
+        }
+
+        return this.resolve(token, requestId);
+      }) ?? [];
+
+    return provider.useFactory!(...params);
+  }
+
+  private construct<T>(
+    target: Constructor<T>,
+    requestId?: string
+  ): T {
+    const injections =
+      Reflect.getMetadata("custom:inject_tokens", target) || {};
+    const args = [];
+    for (const index of Object.keys(injections)) {
+      const token = injections[index];
+      const provider = this.providers.get(token);
+      if (!provider) {
+        args[+index] = this.resolve(token, requestId);
+        continue;
+      }
+      if (provider?.scope === Scope.REQUEST) {
+        args[+index] = this.createRequestScopedProxy(token);
+      } else {
+        args[+index] = this.resolve(token, requestId);
+      }
+    }
+
+    return new target(...args);
+  }
+
+  private createRequestScopedProxy<T>(
+    token: Token<T>,
+  ): T {
+    const cls = this.resolve(CLSService)
+    return (new Proxy({}, {
+      get(_, prop) {
+        const requestId = cls.get('requestId');
+        if (!requestId) {
+          throw new Error(
+            `Request-scoped provider "${String(token)}" accessed outside request context`
+          );
+        }
+        const instance = container.resolve<T>(token, requestId);
+        const value = (instance as any)[prop];
+        return typeof value === "function" ? value.bind(instance) : value;
+      }
+    }) as T);
+  }
+
+  removeRequestInstances(requestId: string) {
+    this.requestCache.delete(requestId);
+  }
+}
+
+export const container = new Container();

package/src/index.ts

@@ -0,0 +1,9 @@
+export * from "./logger";
+export * from "./common";
+export * from "./config";
+export * from "./sg-factory";
+export * from "./sg-application";
+export * from "./routes-config";
+export * from "./set-meta-data";
+export * from "./cls";
+export * from "./di-container";

package/src/logger/index.ts

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

package/src/logger/logger-service.ts

@@ -0,0 +1,48 @@
+import { addColors, createLogger, format, Logger, transports } from "winston";
+
+export class AppLogger {
+  private readonly logger: Logger;
+  constructor() {
+    const colorizer = format.colorize();
+    addColors({
+      info: "bold green",
+      log: "bold white",
+      warn: "bold yellow"
+    });
+    const myFormat = format.printf(({ message }) => {
+      const coloredTime = colorizer.colorize(
+        "log",
+        new Date().toLocaleString()
+      );
+      const coloredServer = colorizer.colorize("info", "[NODE] SHARAN");
+      return `${coloredServer}- ${coloredTime}  ${message}`;
+    });
+    this.logger = createLogger({
+      level: "info",
+      format: format.combine(format.colorize({ all: true }), myFormat),
+      transports: [
+        new transports.Console(),
+      ],
+      exitOnError: false
+    });
+  }
+  log(message: string) {
+    this.logger.log("info", message);
+  }
+
+  debug(message: string): void {
+    this.logger.debug(message);
+  }
+
+  warn(message: string) {
+    this.logger.warn(message);
+  }
+
+  error(message: string) {
+    this.logger.error(message);
+  }
+
+  logWithContext(context: string, message: string) {
+    this.logger.info(`[${context}] ${message}`);
+  }
+}