@abejarano/ts-express-server 1.5.1

package/README.md

@@ -0,0 +1,61 @@
+# TypeScript Express Server Framework
+
+A modular and extensible TypeScript framework for building Express.js servers with a clean architecture pattern that separates concerns between server modules and services.
+
+## Features
+
+- 🏗️ **Modular Architecture**: Build your server using reusable modules
+- 🚀 **Service Management**: Integrate background services that start with your server
+- 📦 **Built-in Modules**: Pre-configured modules for common functionality
+- 🔄 **Graceful Shutdown**: Proper cleanup and shutdown handling
+- ⚡ **Priority System**: Control module initialization order
+- 🛡️ **Type Safety**: Full TypeScript support with strong typing
+- 🔧 **Configurable**: Highly customizable modules and services
+- 🎨 **Decorators**: Clean and declarative controller definition
+
+## Installation
+
+```bash
+npm install @abejarano/ts-express-server
+# or
+yarn add @abejarano/ts-express-server
+```
+
+## Documentation
+
+- [Getting Started](docs/getting-started.md)
+- [Core Concepts](docs/core-concepts.md)
+- [Modules](docs/modules.md)
+- [Using Decorators](docs/decorators.md)
+- [Services](docs/services.md)
+- [Testing Helpers](docs/testing.md)
+- [API Reference](docs/api-reference.md)
+- [Examples](docs/examples.md)
+
+## Contributing
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add some amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## Conventional Commits
+
+We use Conventional Commits to automatically generate releases:
+
+- `feat:` - New feature
+- `fix:` - Bug fix
+- `docs:` - Documentation
+- `style:` - Format, spaces, etc.
+- `refactor:` - Code refactoring
+- `test:` - Add tests
+- `chore:` - Maintenance tasks
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+## Author
+
+Angel Bejarano - angel.bejarano@jaspesoft.com

package/dist/BootstrapServer.d.ts

@@ -0,0 +1,26 @@
+import { Express } from "express";
+import { Server as HttpServer } from "http";
+import { BaseServerModule, BaseServerService } from "./abstract";
+export declare class BootstrapServer {
+    private readonly app;
+    private readonly port;
+    private httpServer?;
+    private modules;
+    private services;
+    constructor(port: number);
+    removeModule(moduleName: string): BootstrapServer;
+    addModule(module: BaseServerModule): BootstrapServer;
+    addModules(modules: BaseServerModule[]): BootstrapServer;
+    addService(service: BaseServerService): BootstrapServer;
+    addServices(services: BaseServerService[]): BootstrapServer;
+    getApp(): Express;
+    getHttpServer(): HttpServer | undefined;
+    initialize(): Promise<void>;
+    start(): Promise<void>;
+    gracefulShutdown(): Promise<void>;
+    getModule<T extends BaseServerModule>(moduleClass: new (...args: any[]) => T): T | undefined;
+    hasModule(moduleClass: new (...args: any[]) => any): boolean;
+    private initializeServices;
+    private initializeServerModules;
+    private setupGracefulShutdown;
+}

package/dist/BootstrapServer.js

@@ -0,0 +1,172 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BootstrapServer = void 0;
+const express_1 = __importDefault(require("express"));
+const body_parser_1 = __importDefault(require("body-parser"));
+const cookie_parser_1 = __importDefault(require("cookie-parser"));
+class BootstrapServer {
+    constructor(port) {
+        this.modules = [];
+        this.services = [];
+        this.port = port;
+        this.app = (0, express_1.default)();
+        this.app.use(express_1.default.json());
+        this.app.use(body_parser_1.default.urlencoded({ extended: true }));
+        this.app.use((0, cookie_parser_1.default)());
+        this.app.set("port", port);
+    }
+    removeModule(moduleName) {
+        this.modules = this.modules.filter((m) => m.getModuleName() !== moduleName);
+        return this;
+    }
+    addModule(module) {
+        const existingModuleIndex = this.modules.findIndex((m) => m.getModuleName() === module.getModuleName());
+        if (existingModuleIndex !== -1) {
+            // Replace existing module
+            this.modules[existingModuleIndex] = module;
+        }
+        else {
+            // Add new module
+            this.modules.push(module);
+        }
+        return this;
+    }
+    addModules(modules) {
+        for (const module of modules) {
+            const existingModuleIndex = this.modules.findIndex((m) => m.getModuleName() === module.getModuleName());
+            if (existingModuleIndex !== -1) {
+                // Replace existing module
+                this.modules[existingModuleIndex] = module;
+            }
+            else {
+                // Add new module
+                this.modules.push(module);
+            }
+        }
+        return this;
+    }
+    addService(service) {
+        this.services.push(service);
+        return this;
+    }
+    addServices(services) {
+        this.services.push(...services);
+        return this;
+    }
+    getApp() {
+        return this.app;
+    }
+    getHttpServer() {
+        return this.httpServer;
+    }
+    async initialize() {
+        await this.initializeServerModules();
+    }
+    async start() {
+        await this.initializeServerModules();
+        return new Promise((resolve) => {
+            this.httpServer = this.app.listen(this.port, () => {
+                console.log(`Server running on port ${this.port}`);
+                this.setupGracefulShutdown();
+                resolve();
+            });
+            this.initializeServices(this.httpServer);
+        });
+    }
+    async gracefulShutdown() {
+        try {
+            console.log("Starting graceful shutdown...");
+            // Execute module shutdown in reverse order
+            const reversedModules = [...this.modules].reverse();
+            for (const module of reversedModules) {
+                if (module.shutdown) {
+                    try {
+                        console.log(`Shutting down module: ${module.getModuleName()}`);
+                        await module.shutdown();
+                        console.log(`Module shutdown completed: ${module.getModuleName()}`);
+                    }
+                    catch (error) {
+                        console.error(`Error shutting down module ${module.getModuleName()}:`, error);
+                    }
+                }
+            }
+            // Stop services in reverse order
+            const reversedServices = [...this.services].reverse();
+            for (const service of reversedServices) {
+                if (service.stop) {
+                    try {
+                        console.log(`Stopping service: ${service.name}`);
+                        await service.stop();
+                        console.log(`Service stopped: ${service.name}`);
+                    }
+                    catch (error) {
+                        console.error(`Error stopping service ${service.name}:`, error);
+                    }
+                }
+            }
+            // Close HTTP server
+            if (this.httpServer) {
+                console.log("Closing HTTP server...");
+                await new Promise((resolve) => {
+                    this.httpServer.close(() => resolve());
+                });
+                console.log("HTTP server closed");
+            }
+            console.log("Graceful shutdown completed. Exiting...");
+            process.exit(0);
+        }
+        catch (error) {
+            console.error("Error during graceful shutdown:", error);
+            process.exit(1);
+        }
+    }
+    // Convenience methods to access specific modules
+    getModule(moduleClass) {
+        return this.modules.find((m) => m instanceof moduleClass);
+    }
+    hasModule(moduleClass) {
+        return this.modules.some((m) => m instanceof moduleClass);
+    }
+    async initializeServices(http) {
+        console.log("Starting services...");
+        for (const service of this.services) {
+            try {
+                await service.start(http);
+                console.log(`Service started: ${service.name}`);
+            }
+            catch (error) {
+                console.error(`Failed to start service ${service.name}:`, error);
+                throw error;
+            }
+        }
+        console.log("All services started successfully");
+    }
+    async initializeServerModules() {
+        // Sort modules by priority (lower number = higher priority)
+        this.modules.sort((a, b) => (a.priority || 0) - (b.priority || 0));
+        console.log("Initializing server modules in priority order:");
+        for (const module of this.modules) {
+            try {
+                await module.init(this.app);
+                console.log(`Module initialized: ${module.getModuleName()}`);
+            }
+            catch (error) {
+                console.error(`Failed to initialize module ${module.getModuleName()}:`, error);
+                throw error;
+            }
+        }
+        console.log("All modules initialized successfully");
+    }
+    setupGracefulShutdown() {
+        const shutdown = async (signal) => {
+            console.log(`${signal} signal received. Shutting down application...`);
+            await this.gracefulShutdown();
+        };
+        process.on("SIGINT", () => shutdown("SIGINT"));
+        process.on("SIGTERM", () => shutdown("SIGTERM"));
+    }
+}
+exports.BootstrapServer = BootstrapServer;

package/dist/BootstrapStandardServer.d.ts

@@ -0,0 +1,20 @@
+import { BootstrapServer } from "./BootstrapServer";
+import { ControllersModule, RoutesModule } from "./modules";
+import { BaseServerModule, BaseServerService } from "./abstract";
+export interface BootstrapStandardServerOptions {
+    modules?: {
+        cors?: BaseServerModule | false;
+        security?: BaseServerModule | false;
+        rateLimit?: BaseServerModule | false;
+        fileUpload?: BaseServerModule | false;
+        requestContext?: BaseServerModule | false;
+        extra?: BaseServerModule[];
+    };
+    services?: BaseServerService[];
+}
+export declare function BootstrapStandardServer(port: number, module: RoutesModule | ControllersModule, services?: BaseServerService[]): BootstrapServer;
+export declare function BootstrapStandardServer(port: number, module: RoutesModule | ControllersModule, services: BaseServerService[], options: BootstrapStandardServerOptions): BootstrapServer;
+export declare function BootstrapStandardServer(port: number, module: RoutesModule | ControllersModule, options: BootstrapStandardServerOptions): BootstrapServer;
+export declare function BootstrapStandardServer(port: number, routes: RoutesModule, controllersModule: ControllersModule, services?: BaseServerService[]): BootstrapServer;
+export declare function BootstrapStandardServer(port: number, routes: RoutesModule, controllersModule: ControllersModule, services: BaseServerService[], options: BootstrapStandardServerOptions): BootstrapServer;
+export declare function BootstrapStandardServer(port: number, routes: RoutesModule, controllersModule: ControllersModule, options: BootstrapStandardServerOptions): BootstrapServer;

package/dist/BootstrapStandardServer.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BootstrapStandardServer = BootstrapStandardServer;
+const BootstrapServer_1 = require("./BootstrapServer");
+const modules_1 = require("./modules");
+function BootstrapStandardServer(port, arg2, arg3, arg4, arg5) {
+    let routesModule;
+    let controllersModule;
+    let services;
+    let options;
+    const setControllersModule = (module) => {
+        if (controllersModule && controllersModule !== module) {
+            throw new Error("ControllersModule provided multiple times. Pass a single instance only.");
+        }
+        controllersModule = module;
+    };
+    if (arg2 instanceof modules_1.RoutesModule) {
+        routesModule = arg2;
+    }
+    else if (arg2 instanceof modules_1.ControllersModule) {
+        setControllersModule(arg2);
+        routesModule = new modules_1.RoutesModule();
+    }
+    else {
+        throw new Error("Invalid second argument. Must be RoutesModule or ControllersModule");
+    }
+    const addServices = (value) => {
+        if (!value?.length) {
+            return;
+        }
+        services = [...(services ?? []), ...value];
+    };
+    const processOptionalArg = (value) => {
+        if (!value) {
+            return;
+        }
+        if (value instanceof modules_1.ControllersModule) {
+            setControllersModule(value);
+            return;
+        }
+        if (Array.isArray(value)) {
+            addServices(value);
+            return;
+        }
+        options = value;
+    };
+    processOptionalArg(arg3);
+    processOptionalArg(arg4);
+    processOptionalArg(arg5);
+    addServices(options?.services);
+    const modulesToRegister = [routesModule];
+    const preset = options?.modules;
+    const registerModule = (factory, override) => {
+        if (override === false) {
+            return;
+        }
+        modulesToRegister.push(override ?? factory());
+    };
+    registerModule(() => new modules_1.CorsModule(), preset?.cors);
+    registerModule(() => new modules_1.SecurityModule(), preset?.security);
+    registerModule(() => new modules_1.RateLimitModule(), preset?.rateLimit);
+    registerModule(() => new modules_1.FileUploadModule(), preset?.fileUpload);
+    registerModule(() => new modules_1.RequestContextModule(), preset?.requestContext);
+    if (preset?.extra?.length) {
+        modulesToRegister.push(...preset.extra);
+    }
+    const expressServer = new BootstrapServer_1.BootstrapServer(port).addModules(modulesToRegister);
+    if (controllersModule) {
+        expressServer.addModule(controllersModule);
+    }
+    if (services) {
+        expressServer.addServices(services);
+    }
+    return expressServer;
+}

package/dist/abstract/ServerModule.d.ts

@@ -0,0 +1,7 @@
+import { Express } from "express";
+export declare abstract class BaseServerModule {
+    priority: number;
+    abstract getModuleName(): string;
+    abstract init(app: Express): Promise<void> | void;
+    shutdown(): Promise<void>;
+}

package/dist/abstract/ServerModule.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseServerModule = void 0;
+class BaseServerModule {
+    constructor() {
+        this.priority = 0;
+    }
+    async shutdown() {
+        // Default empty shutdown
+    }
+}
+exports.BaseServerModule = BaseServerModule;

package/dist/abstract/ServerService.d.ts

@@ -0,0 +1,6 @@
+import { Server as HttpServer } from "http";
+export declare abstract class BaseServerService {
+    abstract name: string;
+    abstract start(http: HttpServer): Promise<void> | void;
+    stop(): Promise<void>;
+}

package/dist/abstract/ServerService.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseServerService = void 0;
+class BaseServerService {
+    async stop() {
+        // Default empty stop
+    }
+}
+exports.BaseServerService = BaseServerService;

package/dist/abstract/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./ServerService";
+export * from "./ServerModule";

package/dist/abstract/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("./ServerService"), exports);
+__exportStar(require("./ServerModule"), exports);

package/dist/controllers/ReportFinanceController.js

@@ -0,0 +1 @@
+"use strict";

package/dist/decorators/Controller.d.ts

@@ -0,0 +1,2 @@
+import "reflect-metadata";
+export declare function Controller(basePath: string): (target: Function) => void;

package/dist/decorators/Controller.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Controller = Controller;
+const MetadataKeys_1 = require("./MetadataKeys");
+require("reflect-metadata");
+function Controller(basePath) {
+    return function (target) {
+        Reflect.defineMetadata(MetadataKeys_1.MetadataKeys.BASE_PATH, basePath, target);
+    };
+}

package/dist/decorators/Handlers.d.ts

@@ -0,0 +1,18 @@
+import "reflect-metadata";
+export declare enum Methods {
+    GET = "get",
+    POST = "post",
+    PUT = "put",
+    DELETE = "delete",
+    PATCH = "patch"
+}
+export interface IRouter {
+    method: Methods;
+    path: string;
+    handlerName: string | symbol;
+}
+export declare const Get: (path: string) => (target: any, key: string, descriptor: PropertyDescriptor) => void;
+export declare const Post: (path: string) => (target: any, key: string, descriptor: PropertyDescriptor) => void;
+export declare const Put: (path: string) => (target: any, key: string, descriptor: PropertyDescriptor) => void;
+export declare const Delete: (path: string) => (target: any, key: string, descriptor: PropertyDescriptor) => void;
+export declare const Patch: (path: string) => (target: any, key: string, descriptor: PropertyDescriptor) => void;

package/dist/decorators/Handlers.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Patch = exports.Delete = exports.Put = exports.Post = exports.Get = exports.Methods = void 0;
+const MetadataKeys_1 = require("./MetadataKeys");
+require("reflect-metadata");
+var Methods;
+(function (Methods) {
+    Methods["GET"] = "get";
+    Methods["POST"] = "post";
+    Methods["PUT"] = "put";
+    Methods["DELETE"] = "delete";
+    Methods["PATCH"] = "patch";
+})(Methods || (exports.Methods = Methods = {}));
+function methodDecorator(method) {
+    return function (path) {
+        return function (target, key, descriptor) {
+            const routers = Reflect.getMetadata(MetadataKeys_1.MetadataKeys.ROUTERS, target) || [];
+            routers.push({
+                method,
+                path,
+                handlerName: key,
+            });
+            Reflect.defineMetadata(MetadataKeys_1.MetadataKeys.ROUTERS, routers, target);
+        };
+    };
+}
+exports.Get = methodDecorator(Methods.GET);
+exports.Post = methodDecorator(Methods.POST);
+exports.Put = methodDecorator(Methods.PUT);
+exports.Delete = methodDecorator(Methods.DELETE);
+exports.Patch = methodDecorator(Methods.PATCH);

package/dist/decorators/MetadataKeys.d.ts

@@ -0,0 +1,6 @@
+export declare enum MetadataKeys {
+    BASE_PATH = "base_path",
+    ROUTERS = "routers",
+    MIDDLEWARE = "middleware",
+    PARAMETERS = "parameters"
+}

package/dist/decorators/MetadataKeys.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetadataKeys = void 0;
+var MetadataKeys;
+(function (MetadataKeys) {
+    MetadataKeys["BASE_PATH"] = "base_path";
+    MetadataKeys["ROUTERS"] = "routers";
+    MetadataKeys["MIDDLEWARE"] = "middleware";
+    MetadataKeys["PARAMETERS"] = "parameters";
+})(MetadataKeys || (exports.MetadataKeys = MetadataKeys = {}));

package/dist/decorators/Parameters.d.ts

@@ -0,0 +1,24 @@
+import "reflect-metadata";
+export declare enum ParameterType {
+    BODY = "body",
+    QUERY = "query",
+    PARAM = "param",
+    HEADERS = "headers",
+    REQUEST = "request",
+    RESPONSE = "response",
+    NEXT = "next",
+    FILE = "file"
+}
+export interface ParameterMetadata {
+    index: number;
+    type: ParameterType;
+    data?: string;
+}
+export declare const Body: (data?: string) => ParameterDecorator;
+export declare const Query: (data?: string) => ParameterDecorator;
+export declare const Param: (data?: string) => ParameterDecorator;
+export declare const Headers: (data?: string) => ParameterDecorator;
+export declare const Req: (data?: string) => ParameterDecorator;
+export declare const Res: (data?: string) => ParameterDecorator;
+export declare const Next: (data?: string) => ParameterDecorator;
+export declare const UploadedFile: (data?: string) => ParameterDecorator;

package/dist/decorators/Parameters.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UploadedFile = exports.Next = exports.Res = exports.Req = exports.Headers = exports.Param = exports.Query = exports.Body = exports.ParameterType = void 0;
+require("reflect-metadata");
+const MetadataKeys_1 = require("./MetadataKeys");
+var ParameterType;
+(function (ParameterType) {
+    ParameterType["BODY"] = "body";
+    ParameterType["QUERY"] = "query";
+    ParameterType["PARAM"] = "param";
+    ParameterType["HEADERS"] = "headers";
+    ParameterType["REQUEST"] = "request";
+    ParameterType["RESPONSE"] = "response";
+    ParameterType["NEXT"] = "next";
+    ParameterType["FILE"] = "file";
+})(ParameterType || (exports.ParameterType = ParameterType = {}));
+// Helper to register parameter metadata for a method
+function addParameterMetadata(target, propertyKey, metadata) {
+    const existingParameters = Reflect.getMetadata(MetadataKeys_1.MetadataKeys.PARAMETERS, target, propertyKey) || [];
+    Reflect.defineMetadata(MetadataKeys_1.MetadataKeys.PARAMETERS, [...existingParameters, metadata].sort((a, b) => a.index - b.index), target, propertyKey);
+}
+function createParameterDecorator(type) {
+    return (data) => (target, propertyKey, parameterIndex) => {
+        if (propertyKey === undefined) {
+            throw new Error("Parameter decorators can only be used on methods");
+        }
+        addParameterMetadata(target, propertyKey, {
+            index: parameterIndex,
+            type,
+            data,
+        });
+    };
+}
+exports.Body = createParameterDecorator(ParameterType.BODY);
+exports.Query = createParameterDecorator(ParameterType.QUERY);
+exports.Param = createParameterDecorator(ParameterType.PARAM);
+exports.Headers = createParameterDecorator(ParameterType.HEADERS);
+exports.Req = createParameterDecorator(ParameterType.REQUEST);
+exports.Res = createParameterDecorator(ParameterType.RESPONSE);
+exports.Next = createParameterDecorator(ParameterType.NEXT);
+exports.UploadedFile = createParameterDecorator(ParameterType.FILE);

package/dist/decorators/Use.d.ts

@@ -0,0 +1,3 @@
+import { RequestHandler } from "express";
+import "reflect-metadata";
+export declare function Use(middleware: RequestHandler | RequestHandler[]): (target: any, key?: string, descriptor?: PropertyDescriptor) => void;

package/dist/decorators/Use.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Use = Use;
+const MetadataKeys_1 = require("./MetadataKeys");
+require("reflect-metadata");
+function Use(middleware) {
+    return function (target, key, descriptor) {
+        const newMiddlewares = Array.isArray(middleware)
+            ? middleware
+            : [middleware];
+        if (key) {
+            // Method decorator
+            const middlewares = Reflect.getMetadata(MetadataKeys_1.MetadataKeys.MIDDLEWARE, target, key) || [];
+            Reflect.defineMetadata(MetadataKeys_1.MetadataKeys.MIDDLEWARE, [...middlewares, ...newMiddlewares], target, key);
+        }
+        else {
+            // Class decorator
+            const middlewares = Reflect.getMetadata(MetadataKeys_1.MetadataKeys.MIDDLEWARE, target) || [];
+            Reflect.defineMetadata(MetadataKeys_1.MetadataKeys.MIDDLEWARE, [...middlewares, ...newMiddlewares], target);
+        }
+    };
+}

package/dist/decorators/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./Controller";
+export * from "./Handlers";
+export * from "./MetadataKeys";
+export * from "./Use";
+export * from "./Parameters";

package/dist/decorators/index.js

@@ -0,0 +1,21 @@
+"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"), exports);
+__exportStar(require("./Handlers"), exports);
+__exportStar(require("./MetadataKeys"), exports);
+__exportStar(require("./Use"), exports);
+__exportStar(require("./Parameters"), exports);

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+import "reflect-metadata";
+export { BootstrapServer } from "./BootstrapServer";
+export { BootstrapStandardServer } from "./BootstrapStandardServer";
+export type { BootstrapStandardServerOptions } from "./BootstrapStandardServer";
+export * from "./modules";
+export * from "./abstract";
+export * from "./decorators";
+export * from "./testing";