@sharangyawali/sg-app 1.0.10

package/README.md

@@ -0,0 +1,24 @@
+# ⚡ SG-APP
+
+A lightweight, opinionated framework built on top of **Express**, inspired by NestJS, designed for **Clean Architecture**, **modularity**, and **developer productivity** — without hiding Express.
+
+---
+
+## ✨ Features
+
+- 🚀 Built on **Express**
+- 🧱 Clean Architecture out of the box
+- 🧩 Module-based structure
+- 🪄 Decorator-based API (RestController, UseGuard, UseInterceptor, etc.)
+- 🔌 Dependency Injection
+- 🧵 Request-scoped context via CLS
+- 📝 Centralized logging & configuration
+- 🛠 Compatible with plain Express middleware
+
+---
+
+## 📥 Installation
+
+```bash
+npm install @sharangyawali/sg-app
+```

package/cls/cls.service.d.ts

@@ -0,0 +1,8 @@
+import { Request } from "express";
+export declare class CLSService {
+    private readonly asyncLocalStorage;
+    constructor();
+    run(req: Request, fn: () => Promise<any> | any): any;
+    set(key: string, value: any): void;
+    get<T = any>(key: string): T;
+}

package/cls/cls.service.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLSService = void 0;
+const async_hooks_1 = require("async_hooks");
+const crypto_1 = __importDefault(require("crypto"));
+class CLSService {
+    asyncLocalStorage;
+    constructor() {
+        this.asyncLocalStorage = new async_hooks_1.AsyncLocalStorage();
+    }
+    run(req, fn) {
+        const requestId = crypto_1.default.randomUUID();
+        return this.asyncLocalStorage.run({ requestId, request: req }, fn);
+    }
+    set(key, value) {
+        const store = this.asyncLocalStorage.getStore();
+        if (!store) {
+            throw new Error("CLS context not initialized");
+        }
+        store[key] = value;
+    }
+    get(key) {
+        const store = this.asyncLocalStorage.getStore();
+        if (!store) {
+            throw new Error("CLS context not initialized");
+        }
+        return store[key];
+    }
+}
+exports.CLSService = CLSService;

package/cls/index.d.ts

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

package/cls/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./cls.service"), exports);

package/common/constants/index.d.ts

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

package/common/constants/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./providers.constants"), exports);

package/common/constants/providers.constants.d.ts

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

package/common/constants/providers.constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REQUEST = void 0;
+exports.REQUEST = "request";

package/common/decorators/component.decorators.d.ts

@@ -0,0 +1,2 @@
+import { InjectableOptions } from "../interface";
+export declare function Component(options?: InjectableOptions): ClassDecorator;

package/common/decorators/component.decorators.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Component = Component;
+const di_container_1 = require("../../di-container");
+const enum_1 = require("../enum");
+function Component(options) {
+    return function (target) {
+        di_container_1.container.register({
+            token: options && options.token ? options.token : target,
+            useClass: target,
+            scope: options && options.scope ? options.scope : enum_1.Scope.SINGLETON
+        });
+    };
+}

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

@@ -0,0 +1,2 @@
+export declare const controllers: any[];
+export declare function RestController(prefix?: string): ClassDecorator;

package/common/decorators/controller.decorator.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.controllers = void 0;
+exports.RestController = RestController;
+const di_container_1 = require("../../di-container");
+const enum_1 = require("../enum");
+exports.controllers = [];
+function RestController(prefix = "/") {
+    return function (target) {
+        target.prototype.prefix = prefix[0] !== "/" ? "/" + prefix : prefix;
+        exports.controllers.push(target);
+        di_container_1.container.register({
+            token: target,
+            useClass: target,
+            scope: enum_1.Scope.SINGLETON
+        });
+    };
+}

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

@@ -0,0 +1,2 @@
+export declare const filters: any[];
+export declare function Catch(): ClassDecorator;

package/common/decorators/filters.decorator.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filters = void 0;
+exports.Catch = Catch;
+const di_container_1 = require("../../di-container");
+const enum_1 = require("../enum");
+exports.filters = [];
+function Catch() {
+    return function (target) {
+        if (typeof target.prototype.catch !== "function")
+            throw new Error(`${target.name} does not implements catch method`);
+        exports.filters.push(target);
+        di_container_1.container.register({
+            token: target,
+            useClass: target,
+            scope: enum_1.Scope.SINGLETON
+        });
+    };
+}

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

@@ -0,0 +1,4 @@
+import { SGGuard } from "../interface";
+export declare const globalGuards: any[];
+export declare function UseGuard(...guardClasses: (SGGuard | Function)[]): MethodDecorator;
+export declare function GlobalGuard(): ClassDecorator;

package/common/decorators/guards.decorator.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.globalGuards = void 0;
+exports.UseGuard = UseGuard;
+exports.GlobalGuard = GlobalGuard;
+const di_container_1 = require("../../di-container");
+const enum_1 = require("../enum");
+exports.globalGuards = [];
+function UseGuard(...guardClasses) {
+    return function (target, propertyKey) {
+        target[propertyKey].guards = guardClasses;
+    };
+}
+function GlobalGuard() {
+    return function (target) {
+        if (typeof target.prototype.canAccess !== "function")
+            throw new Error(`${target.name} does not implements canActivate method`);
+        exports.globalGuards.push(target);
+        di_container_1.container.register({
+            token: target,
+            useClass: target,
+            scope: enum_1.Scope.SINGLETON
+        });
+    };
+}

package/common/decorators/index.d.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/common/decorators/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./controller.decorator"), exports);
+__exportStar(require("./filters.decorator"), exports);
+__exportStar(require("./guards.decorator"), exports);
+__exportStar(require("./interceptors.decorator"), exports);
+__exportStar(require("./middlewares.decorator"), exports);
+__exportStar(require("./parameter-validator.decorator"), exports);
+__exportStar(require("./route-mapping.decorator"), exports);
+__exportStar(require("./module.decorator"), exports);
+__exportStar(require("./component.decorators"), exports);
+__exportStar(require("./inject.decorators"), exports);

package/common/decorators/inject.decorators.d.ts

@@ -0,0 +1,3 @@
+import { Token } from "../interface";
+import "reflect-metadata";
+export declare function Inject(token: Token): ParameterDecorator & PropertyDecorator;

package/common/decorators/inject.decorators.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Inject = Inject;
+require("reflect-metadata");
+function Inject(token) {
+    return (target, _, index) => {
+        if (typeof index === "number") {
+            const existing = Reflect.getMetadata("custom:inject_tokens", target) || {};
+            existing[index] = token;
+            Reflect.defineMetadata("custom:inject_tokens", existing, target);
+        }
+    };
+}

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

@@ -0,0 +1,4 @@
+import { SGInterceptor } from "../interface";
+export declare const globalInterceptors: any[];
+export declare function UseInterceptor(...interceptorClasses: (SGInterceptor | Function)[]): MethodDecorator;
+export declare function GlobalInterceptors(): ClassDecorator;

package/common/decorators/interceptors.decorator.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.globalInterceptors = void 0;
+exports.UseInterceptor = UseInterceptor;
+exports.GlobalInterceptors = GlobalInterceptors;
+const di_container_1 = require("../../di-container");
+const enum_1 = require("../enum");
+exports.globalInterceptors = [];
+function UseInterceptor(...interceptorClasses) {
+    return function (target, propertyKey) {
+        target[propertyKey].interceptors = interceptorClasses;
+    };
+}
+function GlobalInterceptors() {
+    return function (target) {
+        if (typeof target.prototype.intercept !== "function")
+            throw new Error(`${target.name} does not implements intercept method`);
+        exports.globalInterceptors.push(target);
+        di_container_1.container.register({
+            token: target,
+            useClass: target,
+            scope: enum_1.Scope.SINGLETON
+        });
+    };
+}

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

@@ -0,0 +1,3 @@
+import { MiddlewareOptions } from "../interface/global-middleware-options.interface";
+export declare const middlewares: any[];
+export declare function Middleware(options?: MiddlewareOptions): ClassDecorator;

package/common/decorators/middlewares.decorator.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.middlewares = void 0;
+exports.Middleware = Middleware;
+const di_container_1 = require("../../di-container");
+const scope_enum_1 = require("../enum/scope.enum");
+exports.middlewares = [];
+function Middleware(options) {
+    return function (target) {
+        if (typeof target.prototype.use !== "function")
+            throw new Error(`${target.name} does not implements use method`);
+        exports.middlewares.push({ target, options });
+        di_container_1.container.register({
+            token: target,
+            useClass: target,
+            scope: scope_enum_1.Scope.SINGLETON
+        });
+    };
+}

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

@@ -0,0 +1,2 @@
+import { ModuleOptions } from "../interface";
+export declare function Module(options?: ModuleOptions): ClassDecorator;

package/common/decorators/module.decorator.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Module = Module;
+const di_container_1 = require("../../di-container");
+const enum_1 = require("../enum");
+function Module(options) {
+    return function (target) {
+        if (options.providers) {
+            options.providers.forEach((p) => {
+                if (Object.keys(p).length > 0) {
+                    const provider = p;
+                    if (provider.useClass || provider.useValue || provider.useFactory)
+                        di_container_1.container.register({
+                            scope: provider.scope || enum_1.Scope.SINGLETON,
+                            token: provider.token,
+                            useValue: provider.useValue,
+                            useClass: provider.useClass,
+                            useFactory: provider.useFactory,
+                            inject: provider.inject
+                        });
+                }
+            });
+        }
+    };
+}

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

@@ -0,0 +1,7 @@
+export declare const Query: (dtoClass: any) => ParameterDecorator;
+export declare const Body: (dtoClass: any) => ParameterDecorator;
+export declare const Params: (dtoClass: any) => ParameterDecorator;
+export declare const UploadedFile: () => ParameterDecorator;
+export declare const UploadedFiles: () => ParameterDecorator;
+export declare const Req: () => ParameterDecorator;
+export declare const Res: () => ParameterDecorator;

package/common/decorators/parameter-validator.decorator.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Res = exports.Req = exports.UploadedFiles = exports.UploadedFile = exports.Params = exports.Body = exports.Query = void 0;
+const enum_1 = require("../enum");
+function Validator(data, dtoClass) {
+    return function (target, propertyKey, index) {
+        const parameters = target[propertyKey].parameters || [];
+        parameters.push({ index, dtoClass, paramType: data });
+        target[propertyKey].parameters = parameters;
+    };
+}
+const Query = (dtoClass) => Validator(enum_1.RequestParameters.QUERY, dtoClass);
+exports.Query = Query;
+const Body = (dtoClass) => Validator(enum_1.RequestParameters.BODY, dtoClass);
+exports.Body = Body;
+const Params = (dtoClass) => Validator(enum_1.RequestParameters.PARAMS, dtoClass);
+exports.Params = Params;
+const UploadedFile = () => Validator(enum_1.RequestParameters.FILE, null);
+exports.UploadedFile = UploadedFile;
+const UploadedFiles = () => Validator(enum_1.RequestParameters.FILES, null);
+exports.UploadedFiles = UploadedFiles;
+const Req = () => Validator(enum_1.RequestParameters.REQUEST, null);
+exports.Req = Req;
+const Res = () => Validator(enum_1.RequestParameters.RESPONSE, null);
+exports.Res = Res;

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

@@ -0,0 +1,5 @@
+export declare const Get: (path?: string) => MethodDecorator;
+export declare const Post: (path?: string) => MethodDecorator;
+export declare const Put: (path?: string) => MethodDecorator;
+export declare const Patch: (path?: string) => MethodDecorator;
+export declare const Delete: (path?: string) => MethodDecorator;

package/common/decorators/route-mapping.decorator.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Delete = exports.Patch = exports.Put = exports.Post = exports.Get = void 0;
+function RequestMapping(method, path) {
+    return function (target, propertyKey) {
+        const methods = 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;
+    };
+}
+const Get = (path) => RequestMapping("get", path);
+exports.Get = Get;
+const Post = (path) => RequestMapping("post", path);
+exports.Post = Post;
+const Put = (path) => RequestMapping("put", path);
+exports.Put = Put;
+const Patch = (path) => RequestMapping("patch", path);
+exports.Patch = Patch;
+const Delete = (path) => RequestMapping("delete", path);
+exports.Delete = Delete;

package/common/enum/index.d.ts

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

package/common/enum/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./request-method.enum"), exports);
+__exportStar(require("./request-parameters.enum"), exports);
+__exportStar(require("./scope.enum"), exports);

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

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

package/common/enum/request-method.enum.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestMethodEnum = void 0;
+var RequestMethodEnum;
+(function (RequestMethodEnum) {
+    RequestMethodEnum["POST"] = "post";
+    RequestMethodEnum["GET"] = "get";
+    RequestMethodEnum["DELETE"] = "delete";
+    RequestMethodEnum["PUT"] = "put";
+    RequestMethodEnum["PATCH"] = "patch";
+    RequestMethodEnum["ALL"] = "all";
+    RequestMethodEnum["OPTIONS"] = "options";
+    RequestMethodEnum["HEAD"] = "head";
+    RequestMethodEnum["SEARCH"] = "search";
+})(RequestMethodEnum || (exports.RequestMethodEnum = RequestMethodEnum = {}));

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

@@ -0,0 +1,9 @@
+export declare enum RequestParameters {
+    QUERY = "query",
+    BODY = "body",
+    PARAMS = "params",
+    FILE = "file",
+    FILES = "files",
+    REQUEST = "req",
+    RESPONSE = "res"
+}

package/common/enum/request-parameters.enum.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestParameters = void 0;
+var RequestParameters;
+(function (RequestParameters) {
+    RequestParameters["QUERY"] = "query";
+    RequestParameters["BODY"] = "body";
+    RequestParameters["PARAMS"] = "params";
+    RequestParameters["FILE"] = "file";
+    RequestParameters["FILES"] = "files";
+    RequestParameters["REQUEST"] = "req";
+    RequestParameters["RESPONSE"] = "res";
+})(RequestParameters || (exports.RequestParameters = RequestParameters = {}));

package/common/enum/scope.enum.d.ts

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

package/common/enum/scope.enum.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Scope = void 0;
+var Scope;
+(function (Scope) {
+    Scope["SINGLETON"] = "singleton";
+    Scope["TRANSIENT"] = "transient";
+    Scope["REQUEST"] = "request";
+})(Scope || (exports.Scope = Scope = {}));

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

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

package/common/http/http-context.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpContext = void 0;
+class HttpContext {
+    request;
+    response;
+    methodMeta;
+    req;
+    res;
+    constructor(request, response, methodMeta) {
+        this.request = request;
+        this.response = response;
+        this.methodMeta = methodMeta;
+        this.req = request;
+        this.res = response;
+    }
+    getRequest() {
+        return this.req;
+    }
+    getResponse() {
+        return this.res;
+    }
+    getMetaData(key) {
+        return this.methodMeta[key];
+    }
+}
+exports.HttpContext = HttpContext;

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

@@ -0,0 +1,7 @@
+export declare class HttpException extends Error {
+    private readonly msg;
+    private readonly status;
+    readonly message: any;
+    readonly statusCode: number;
+    constructor(msg?: any, status?: number);
+}

package/common/http/http-exception.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpException = void 0;
+class HttpException extends Error {
+    msg;
+    status;
+    message;
+    statusCode;
+    constructor(msg = "Internal Server Error", status = 500) {
+        super(msg);
+        this.msg = msg;
+        this.status = status;
+        this.message = msg;
+        this.statusCode = status;
+    }
+}
+exports.HttpException = HttpException;

package/common/http/index.d.ts

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

package/common/http/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./http-context"), exports);
+__exportStar(require("./http-exception"), exports);

package/common/index.d.ts

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