@synchjs/ewb 1.0.0

package/dist/Components/Server.js

@@ -0,0 +1,441 @@
+import express from "express";
+import fs from "fs";
+import path from "path";
+import swaggerUi from "swagger-ui-express";
+const swaggerJsdoc = require("swagger-jsdoc");
+import helmet from "helmet";
+import cors from "cors";
+import rateLimit from "express-rate-limit";
+import Ajv from "ajv";
+import addFormats from "ajv-formats";
+import { MetadataStorage } from "../Decorations";
+import * as jwt from "jsonwebtoken";
+import { AUTH_METADATA_KEY, PUBLIC_METADATA_KEY, } from "../Decorations/Authorized";
+import { SECURITY_METADATA_KEY, } from "../Decorations/Security";
+import { TAILWIND_METADATA_KEY, } from "../Decorations/Tailwind";
+import { ServeMemoryStore } from "./ServeMemoryStore";
+import boxen from "boxen";
+import pc from "picocolors";
+export class Server {
+    _app;
+    _port;
+    _controllersDir;
+    _id;
+    _enableSwagger;
+    _swaggerPath;
+    _enableLogging;
+    _securitySchemes;
+    _ajv;
+    _securityHandlers;
+    _container;
+    _serverInstance;
+    // Stats
+    _controllerCount = 0;
+    _routeCount = 0;
+    _tailwindEnabled = false;
+    constructor(options) {
+        this._port = options.port;
+        this._app = express();
+        this._id = options.id;
+        this._enableSwagger = options.enableSwagger || false;
+        this._swaggerPath = options.swaggerPath || "/api-docs";
+        this._enableLogging =
+            options.logging === undefined ? true : options.logging;
+        this._controllersDir = options.controllersDir || "controllers";
+        this._securityHandlers = options.securityHandlers || {};
+        this._securitySchemes = options.securitySchemes;
+        this._container = options.container;
+        // Initialize AJV
+        this._ajv = new Ajv({ allErrors: true, strict: false });
+        addFormats(this._ajv);
+        // Security Middleware
+        this._app.use(helmet(options.helmetOptions));
+        this._app.use(cors(options.corsOptions));
+        this._app.use(rateLimit(options.rateLimitOptions || {
+            windowMs: 15 * 60 * 1000,
+            max: 100,
+        }));
+        this._app.use(express.json());
+        global.servers.set(this._id, this._app);
+    }
+    log(message) {
+        if (this._enableLogging) {
+            console.log(message);
+        }
+    }
+    async init() {
+        await this.loadControllers();
+        if (this._enableSwagger) {
+            this.setupSwagger();
+        }
+        // Serve Static Assets from Memory Store
+        this._app.use((req, res, next) => {
+            if (req.method !== "GET" && req.method !== "HEAD")
+                return next();
+            const asset = ServeMemoryStore.instance.getAsset(req.path);
+            if (asset) {
+                res.type(asset.type).send(Buffer.from(asset.content));
+                return;
+            }
+            next();
+        });
+        // Global Error Handler
+        this._app.use((err, req, res, next) => {
+            console.error(`[${this._id}] Error:`, err);
+            res.status(err.status || 500).json({
+                error: "Internal Server Error",
+                message: "An unexpected error occurred",
+            });
+        });
+        this._serverInstance = this._app.listen(this._port, () => {
+            if (this._enableLogging) {
+                this.printStartupMessage();
+            }
+        });
+    }
+    printStartupMessage() {
+        const pad = (str) => str.padEnd(15);
+        const lines = [
+            pc.green(`Server '${this._id}' is running!`),
+            "",
+            `${pc.bold(pad("Port:"))}${this._port}`,
+            `${pc.bold(pad("PID:"))}${process.pid}`,
+            `${pc.bold(pad("Controllers:"))}${this._controllerCount}`,
+            `${pc.bold(pad("Routes:"))}${this._routeCount}`,
+            `${pc.bold(pad("Tailwind:"))}${this._tailwindEnabled ? pc.blue("Enabled") : pc.dim("Disabled")}`,
+        ];
+        if (this._enableSwagger) {
+            lines.push(`${pc.bold(pad("Swagger:"))}http://localhost:${this._port}${this._swaggerPath}`);
+        }
+        console.log(boxen(lines.join("\n"), {
+            padding: 1,
+            margin: 1,
+            borderStyle: "round",
+            borderColor: "green",
+            title: "Server Status",
+            titleAlignment: "center",
+        }));
+    }
+    close() {
+        if (this._serverInstance) {
+            this._serverInstance.close(() => {
+                this.log(`Server '${this._id}' stopped.`);
+            });
+        }
+        global.servers.delete(this._id);
+    }
+    async loadControllers() {
+        const absoluteControllersPath = path.resolve(process.cwd(), this._controllersDir);
+        if (!fs.existsSync(absoluteControllersPath)) {
+            console.warn(`Controllers directory not found: ${absoluteControllersPath}`);
+            return;
+        }
+        const files = fs
+            .readdirSync(absoluteControllersPath)
+            .filter((file) => file.endsWith(".ts") || file.endsWith(".js"));
+        for (const file of files) {
+            const filePath = path.join(absoluteControllersPath, file);
+            await import(filePath);
+        }
+        const controllers = MetadataStorage.instance.getControllers();
+        for (const controller of controllers) {
+            if (controller.serverIds && !controller.serverIds.includes(this._id)) {
+                continue;
+            }
+            this._controllerCount++;
+            // Check for Tailwind metadata
+            const tailwindOptions = Reflect.getMetadata(TAILWIND_METADATA_KEY, controller.target);
+            if (tailwindOptions?.enable) {
+                this._tailwindEnabled = true;
+            }
+            const instance = this._container?.get
+                ? this._container.get(controller.target)
+                : new controller.target();
+            // Check class level auth
+            const classAuthInfo = Reflect.getMetadata(AUTH_METADATA_KEY, controller.target);
+            for (const route of controller.routes) {
+                const fullPath = (controller.path + "/" + route.path).replace(/\/+/g, "/");
+                const middlewares = [];
+                // Check method level metadata
+                const methodAuthInfo = Reflect.getMetadata(AUTH_METADATA_KEY, controller.target.prototype, route.handlerName);
+                const isPublic = Reflect.getMetadata(PUBLIC_METADATA_KEY, controller.target.prototype, route.handlerName);
+                // Determine if auth is required and which secret to use
+                let authSecret;
+                if (isPublic) {
+                    authSecret = undefined;
+                }
+                else if (methodAuthInfo) {
+                    authSecret = methodAuthInfo.secret || process.env.JWT_SECRET;
+                }
+                else if (classAuthInfo) {
+                    authSecret = classAuthInfo.secret || process.env.JWT_SECRET;
+                }
+                // 1. Auth Middleware (New Decorator Logic)
+                if (authSecret) {
+                    middlewares.push(this.createJwtMiddleware(authSecret));
+                    // Inject Swagger security definition automatically
+                    if (!route.swagger) {
+                        route.swagger = {
+                            responses: {
+                                200: {
+                                    description: "Default response",
+                                },
+                            },
+                        };
+                    }
+                    if (!route.swagger.security) {
+                        route.swagger.security = [];
+                    }
+                    // specific check to avoid duplicating if user manually added it
+                    const hasBearer = route.swagger.security.some((s) => "bearerAuth" in s);
+                    if (!hasBearer) {
+                        route.swagger.security.push({ bearerAuth: [] });
+                    }
+                }
+                // 2. Generic Security Middleware (@Security, @OAuth, etc)
+                const classGenericSecurity = Reflect.getMetadata(SECURITY_METADATA_KEY, controller.target) || [];
+                const methodGenericSecurity = Reflect.getMetadata(SECURITY_METADATA_KEY, controller.target.prototype, route.handlerName) || [];
+                let genericRequirements = [];
+                if (isPublic) {
+                    // If public, we might want to skip class generic security too?
+                    // Usually yes.
+                    genericRequirements = [...methodGenericSecurity];
+                }
+                else {
+                    genericRequirements = [
+                        ...classGenericSecurity,
+                        ...methodGenericSecurity,
+                    ];
+                }
+                // Add to Swagger
+                if (genericRequirements.length > 0) {
+                    if (!route.swagger) {
+                        route.swagger = {
+                            responses: {
+                                200: { description: "Default response" },
+                            },
+                        };
+                    }
+                    if (!route.swagger.security) {
+                        route.swagger.security = [];
+                    }
+                    route.swagger.security.push(...genericRequirements);
+                }
+                // 3. Auth Middleware (Old logic - support existing manual config + generic)
+                const manualRequirements = [
+                    ...(route.swagger?.security || []),
+                    ...(controller.security || []),
+                ];
+                // We already pushed genericRequirements to route.swagger.security, so manualRequirements includes them?
+                // Wait, route.swagger.security is updated above.
+                // So manualRequirements now has everything including bearerAuth (pushed above) and generic (pushed above).
+                // BUT, controller.security (from @Controller options) might duplicate classGenericSecurity?
+                // Let's rely on route.swagger.security + controller.security.
+                // And we should filter out duplicates if necessary, but Swagger UI handles it usually (OR logic between items in array).
+                // Actually, genericRequirements are added to route.swagger.security.
+                // So we can just use route.swagger.security.
+                // However, controller.security is separate.
+                const allSecurityRequirements = [
+                    ...(route.swagger?.security || []),
+                    ...(controller.security || []),
+                ];
+                // Filter out bearerAuth if handled by createJwtMiddleware (to avoid double check if handler is missing)
+                // createJwtMiddleware handles 'bearerAuth'.
+                // createAuthMiddleware handles everything else via securityHandlers.
+                // If we have 'bearerAuth' in requirements, createAuthMiddleware will look for a handler for 'bearerAuth'.
+                // If user didn't provide one, it warns.
+                // We should probably allow 'bearerAuth' in createAuthMiddleware IF user provided a handler.
+                // But we added createJwtMiddleware explicitly.
+                // So we should filter 'bearerAuth' out of requirements passed to createAuthMiddleware UNLESS user provided a handler for it?
+                // Or just let it run. If user provides handler, it runs twice?
+                // createJwtMiddleware is added if `authSecret` is true (from @BearerAuth).
+                // If `bearerAuth` is in swagger because of @BearerAuth, we risk running twice if user adds handler.
+                // But `@BearerAuth` logic uses `createJwtMiddleware`.
+                // The `genericRequirements` logic adds to swagger.
+                // Let's assume standard usage: use @BearerAuth OR @Security("bearerAuth"). Not both.
+                if (allSecurityRequirements.length > 0) {
+                    middlewares.push(this.createAuthMiddleware(allSecurityRequirements));
+                }
+                // 4. Validation Middleware
+                // 2. Validation Middleware
+                if (route.swagger?.requestBody &&
+                    route.swagger.requestBody.content?.["application/json"]
+                        ?.schema) {
+                    const schema = route.swagger.requestBody.content["application/json"].schema;
+                    middlewares.push(this.createValidationMiddleware(schema));
+                }
+                // 3. Custom Middlewares
+                // Controller Level
+                if (controller.middlewares) {
+                    middlewares.push(...controller.middlewares);
+                }
+                // Route Level
+                if (route.middlewares) {
+                    middlewares.push(...route.middlewares);
+                }
+                // 3. Route Handler
+                const handler = (req, res, next) => {
+                    try {
+                        const result = instance[route.handlerName](req, res, next);
+                        const handleResult = (val) => {
+                            if (val !== undefined && !res.headersSent) {
+                                if (typeof val === "string") {
+                                    res.send(val);
+                                }
+                                else if (typeof val === "object") {
+                                    res.json(val);
+                                }
+                            }
+                        };
+                        if (result instanceof Promise) {
+                            result.then(handleResult).catch(next);
+                        }
+                        else {
+                            handleResult(result);
+                        }
+                    }
+                    catch (error) {
+                        next(error);
+                    }
+                };
+                this._app[route.method](fullPath, ...middlewares, handler);
+                this._routeCount++;
+            }
+        }
+    }
+    createJwtMiddleware(secret) {
+        return (req, res, next) => {
+            const authHeader = req.headers.authorization;
+            if (!authHeader || !authHeader.startsWith("Bearer ")) {
+                return res
+                    .status(401)
+                    .json({ error: "Unauthorized: Missing Bearer token" });
+            }
+            const token = authHeader.split(" ")[1];
+            try {
+                const decoded = jwt.verify(token, secret);
+                req.user = decoded; // Attach user to request
+                next();
+            }
+            catch (err) {
+                return res.status(403).json({ error: "Forbidden: Invalid token" });
+            }
+        };
+    }
+    createAuthMiddleware(requirements) {
+        return (req, res, next) => {
+            if (requirements.length === 0)
+                return next();
+            let requirementIndex = 0;
+            const checkRequirement = (index) => {
+                if (index >= requirements.length) {
+                    // All requirements failed
+                    return res.status(401).json({ error: "Unauthorized" });
+                }
+                const requirement = requirements[index];
+                const schemes = Object.keys(requirement);
+                if (schemes.length === 0) {
+                    // Empty requirement means public access is allowed
+                    return next();
+                }
+                const checkScheme = (schemeIndex) => {
+                    if (schemeIndex >= schemes.length) {
+                        // All schemes in this requirement passed
+                        return next();
+                    }
+                    const scheme = schemes[schemeIndex];
+                    const handler = this._securityHandlers[scheme];
+                    if (!handler) {
+                        console.warn(`[${this._id}] Security handler for '${scheme}' not configured.`);
+                        // If handler is missing, this scheme fails. Ideally, we should treat it as an error.
+                        // But since this is one of potentially many AND schemes, failure here means this requirement fails.
+                        // Move to next requirement.
+                        return checkRequirement(index + 1);
+                    }
+                    handler(req, res, (err) => {
+                        if (err) {
+                            // This scheme failed, so the whole requirement fails.
+                            // Move to the next requirement (OR logic).
+                            return checkRequirement(index + 1);
+                        }
+                        // This scheme passed, move to the next scheme in the same requirement (AND logic).
+                        checkScheme(schemeIndex + 1);
+                    });
+                };
+                checkScheme(0);
+            };
+            checkRequirement(0);
+        };
+    }
+    createValidationMiddleware(schema) {
+        const validate = this._ajv.compile(schema);
+        return (req, res, next) => {
+            const valid = validate(req.body);
+            if (!valid) {
+                return res.status(400).json({
+                    error: "Validation Error",
+                    details: validate.errors,
+                });
+            }
+            next();
+        };
+    }
+    setupSwagger() {
+        const controllers = MetadataStorage.instance
+            .getControllers()
+            .filter((c) => !c.serverIds || c.serverIds.includes(this._id));
+        const paths = {};
+        for (const controller of controllers) {
+            for (const route of controller.routes) {
+                const fullPath = (controller.path + "/" + route.path)
+                    .replace(/\/+/g, "/")
+                    .replace(/:([^/]+)/g, "{$1}");
+                if (!paths[fullPath]) {
+                    paths[fullPath] = {};
+                }
+                const operation = route.swagger
+                    ? { ...route.swagger }
+                    : {
+                        responses: {
+                            200: {
+                                description: "Default response",
+                            },
+                        },
+                    };
+                if (controller.tags) {
+                    operation.tags = [...(operation.tags || []), ...controller.tags];
+                }
+                if (controller.security) {
+                    operation.security = [
+                        ...(operation.security || []),
+                        ...controller.security,
+                    ];
+                }
+                paths[fullPath][route.method] = operation;
+            }
+        }
+        const options = {
+            definition: {
+                openapi: "3.0.0",
+                info: {
+                    title: `Server ${this._id} API`,
+                    version: "1.0.0",
+                },
+                paths: paths,
+                components: {
+                    securitySchemes: {
+                        bearerAuth: {
+                            type: "http",
+                            scheme: "bearer",
+                            bearerFormat: "JWT",
+                        },
+                        ...this._securitySchemes,
+                    },
+                },
+            },
+            apis: [],
+        };
+        const specs = swaggerJsdoc(options);
+        this._app.use(this._swaggerPath, swaggerUi.serve, swaggerUi.setup(specs));
+    }
+}

package/dist/Decorations/Authorized.d.ts

@@ -0,0 +1,8 @@
+export declare const AUTH_METADATA_KEY = "auth:info";
+export declare const PUBLIC_METADATA_KEY = "auth:public";
+export interface AuthInfo {
+    secret?: string;
+}
+export declare function BearerAuth(secret?: string): MethodDecorator & ClassDecorator;
+export declare function Public(): MethodDecorator;
+//# sourceMappingURL=Authorized.d.ts.map

package/dist/Decorations/Authorized.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Authorized.d.ts","sourceRoot":"","sources":["../../src/Decorations/Authorized.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,iBAAiB,cAAc,CAAC;AAC7C,eAAO,MAAM,mBAAmB,gBAAgB,CAAC;AAEjD,MAAM,WAAW,QAAQ;IACvB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,wBAAgB,UAAU,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,eAAe,GAAG,cAAc,CAmB5E;AAED,wBAAgB,MAAM,IAAI,eAAe,CAQxC"}

package/dist/Decorations/Authorized.js

@@ -0,0 +1,20 @@
+// Key to store auth metadata
+export const AUTH_METADATA_KEY = "auth:info";
+export const PUBLIC_METADATA_KEY = "auth:public";
+export function BearerAuth(secret) {
+    return function (target, propertyKey, descriptor) {
+        // If used on a method
+        if (propertyKey) {
+            Reflect.defineMetadata(AUTH_METADATA_KEY, { secret }, target, propertyKey);
+        }
+        else {
+            // If used on a class
+            Reflect.defineMetadata(AUTH_METADATA_KEY, { secret }, target);
+        }
+    };
+}
+export function Public() {
+    return function (target, propertyKey, descriptor) {
+        Reflect.defineMetadata(PUBLIC_METADATA_KEY, true, target, propertyKey);
+    };
+}

package/dist/Decorations/Controller.d.ts

@@ -0,0 +1,8 @@
+import { OpenAPIV3 } from "openapi-types";
+export interface ControllerOptions {
+    serverIds?: string[];
+    tags?: string[];
+    security?: OpenAPIV3.SecurityRequirementObject[];
+}
+export declare function Controller(path: string, options?: ControllerOptions): (target: Function) => void;
+//# sourceMappingURL=Controller.d.ts.map

package/dist/Decorations/Controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Controller.d.ts","sourceRoot":"","sources":["../../src/Decorations/Controller.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAG1C,MAAM,WAAW,iBAAiB;IAChC,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,QAAQ,CAAC,EAAE,SAAS,CAAC,yBAAyB,EAAE,CAAC;CAClD;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,iBAAiB,IACjD,QAAQ,QAAQ,UAyBlC"}

package/dist/Decorations/Controller.js

@@ -0,0 +1,21 @@
+import { MetadataStorage } from "./Metadata";
+export function Controller(path, options) {
+    return function (target) {
+        const routes = MetadataStorage.instance.getRoutes(target);
+        const controllerMiddlewares = Reflect.getMetadata("middlewares", target) || [];
+        // Inject middleware into routes
+        routes.forEach((route) => {
+            route.middlewares =
+                Reflect.getMetadata("middlewares", target.prototype, route.handlerName) || [];
+        });
+        MetadataStorage.instance.addController({
+            target: target,
+            path: path,
+            serverIds: options?.serverIds,
+            tags: options?.tags,
+            security: options?.security,
+            middlewares: controllerMiddlewares,
+            routes: routes,
+        });
+    };
+}

package/dist/Decorations/Metadata.d.ts

@@ -0,0 +1,30 @@
+import "reflect-metadata";
+import type { RequestHandler } from "express";
+import { OpenAPIV3 } from "openapi-types";
+export interface RouteDefinition {
+    method: "get" | "post" | "put" | "delete" | "patch";
+    path: string;
+    handlerName: string;
+    swagger?: OpenAPIV3.OperationObject;
+    middlewares?: RequestHandler[];
+}
+export interface ControllerDefinition {
+    target: any;
+    path: string;
+    serverIds?: string[];
+    routes: RouteDefinition[];
+    tags?: string[];
+    security?: OpenAPIV3.SecurityRequirementObject[];
+    middlewares?: RequestHandler[];
+}
+export declare class MetadataStorage {
+    private static _instance;
+    private _controllers;
+    private constructor();
+    static get instance(): MetadataStorage;
+    addController(controller: ControllerDefinition): void;
+    getControllers(): ControllerDefinition[];
+    addRoute(target: any, route: RouteDefinition): void;
+    getRoutes(target: any): RouteDefinition[];
+}
+//# sourceMappingURL=Metadata.d.ts.map

package/dist/Decorations/Metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Metadata.d.ts","sourceRoot":"","sources":["../../src/Decorations/Metadata.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAE1C,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,QAAQ,GAAG,OAAO,CAAC;IACpD,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,SAAS,CAAC,eAAe,CAAC;IACpC,WAAW,CAAC,EAAE,cAAc,EAAE,CAAC;CAChC;AAED,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,GAAG,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,MAAM,EAAE,eAAe,EAAE,CAAC;IAC1B,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,QAAQ,CAAC,EAAE,SAAS,CAAC,yBAAyB,EAAE,CAAC;IACjD,WAAW,CAAC,EAAE,cAAc,EAAE,CAAC;CAChC;AAED,qBAAa,eAAe;IAC1B,OAAO,CAAC,MAAM,CAAC,SAAS,CAAkB;IAC1C,OAAO,CAAC,YAAY,CAA8B;IAElD,OAAO;IAEP,WAAkB,QAAQ,IAAI,eAAe,CAK5C;IAEM,aAAa,CAAC,UAAU,EAAE,oBAAoB;IAI9C,cAAc,IAAI,oBAAoB,EAAE;IAIxC,QAAQ,CAAC,MAAM,EAAE,GAAG,EAAE,KAAK,EAAE,eAAe;IAc5C,SAAS,CAAC,MAAM,EAAE,GAAG,GAAG,eAAe,EAAE;CAGjD"}

package/dist/Decorations/Metadata.js

@@ -0,0 +1,32 @@
+import "reflect-metadata";
+export class MetadataStorage {
+    static _instance;
+    _controllers = [];
+    constructor() { }
+    static get instance() {
+        if (!MetadataStorage._instance) {
+            MetadataStorage._instance = new MetadataStorage();
+        }
+        return MetadataStorage._instance;
+    }
+    addController(controller) {
+        this._controllers.push(controller);
+    }
+    getControllers() {
+        return this._controllers;
+    }
+    addRoute(target, route) {
+        const existingController = this._controllers.find((c) => c.target === target);
+        if (existingController) {
+            existingController.routes.push(route);
+        }
+        else {
+            const routes = Reflect.getMetadata("routes", target) || [];
+            routes.push(route);
+            Reflect.defineMetadata("routes", routes, target);
+        }
+    }
+    getRoutes(target) {
+        return Reflect.getMetadata("routes", target) || [];
+    }
+}

package/dist/Decorations/Methods.d.ts

@@ -0,0 +1,8 @@
+import "reflect-metadata";
+import { OpenAPIV3 } from "openapi-types";
+export declare function Get(path: string, swagger?: OpenAPIV3.OperationObject): MethodDecorator;
+export declare function Post(path: string, swagger?: OpenAPIV3.OperationObject): MethodDecorator;
+export declare function Put(path: string, swagger?: OpenAPIV3.OperationObject): MethodDecorator;
+export declare function Delete(path: string, swagger?: OpenAPIV3.OperationObject): MethodDecorator;
+export declare function Patch(path: string, swagger?: OpenAPIV3.OperationObject): MethodDecorator;
+//# sourceMappingURL=Methods.d.ts.map

package/dist/Decorations/Methods.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Methods.d.ts","sourceRoot":"","sources":["../../src/Decorations/Methods.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC;AAE1B,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAE1C,wBAAgB,GAAG,CACjB,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,SAAS,CAAC,eAAe,GAClC,eAAe,CAajB;AAED,wBAAgB,IAAI,CAClB,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,SAAS,CAAC,eAAe,GAClC,eAAe,CAajB;AAED,wBAAgB,GAAG,CACjB,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,SAAS,CAAC,eAAe,GAClC,eAAe,CAajB;AAED,wBAAgB,MAAM,CACpB,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,SAAS,CAAC,eAAe,GAClC,eAAe,CAajB;AAED,wBAAgB,KAAK,CACnB,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,SAAS,CAAC,eAAe,GAClC,eAAe,CAajB"}

package/dist/Decorations/Methods.js

@@ -0,0 +1,52 @@
+import "reflect-metadata";
+import { MetadataStorage } from "./Metadata";
+export function Get(path, swagger) {
+    return function (target, propertyKey, descriptor) {
+        MetadataStorage.instance.addRoute(target.constructor, {
+            method: "get",
+            path,
+            handlerName: propertyKey,
+            swagger,
+        });
+    };
+}
+export function Post(path, swagger) {
+    return function (target, propertyKey, descriptor) {
+        MetadataStorage.instance.addRoute(target.constructor, {
+            method: "post",
+            path,
+            handlerName: propertyKey,
+            swagger,
+        });
+    };
+}
+export function Put(path, swagger) {
+    return function (target, propertyKey, descriptor) {
+        MetadataStorage.instance.addRoute(target.constructor, {
+            method: "put",
+            path,
+            handlerName: propertyKey,
+            swagger,
+        });
+    };
+}
+export function Delete(path, swagger) {
+    return function (target, propertyKey, descriptor) {
+        MetadataStorage.instance.addRoute(target.constructor, {
+            method: "delete",
+            path,
+            handlerName: propertyKey,
+            swagger,
+        });
+    };
+}
+export function Patch(path, swagger) {
+    return function (target, propertyKey, descriptor) {
+        MetadataStorage.instance.addRoute(target.constructor, {
+            method: "patch",
+            path,
+            handlerName: propertyKey,
+            swagger,
+        });
+    };
+}

package/dist/Decorations/Middleware.d.ts

@@ -0,0 +1,5 @@
+import "reflect-metadata";
+import type { RequestHandler } from "express";
+export declare function Use(...middlewares: RequestHandler[]): (target: any, propertyKey?: string | symbol, descriptor?: PropertyDescriptor) => void;
+export declare function Middleware(...middlewares: RequestHandler[]): (target: any, propertyKey?: string | symbol, descriptor?: PropertyDescriptor) => void;
+//# sourceMappingURL=Middleware.d.ts.map

package/dist/Decorations/Middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Middleware.d.ts","sourceRoot":"","sources":["../../src/Decorations/Middleware.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C,wBAAgB,GAAG,CAAC,GAAG,WAAW,EAAE,cAAc,EAAE,IAEhD,QAAQ,GAAG,EACX,cAAc,MAAM,GAAG,MAAM,EAC7B,aAAa,kBAAkB,UAuBlC;AACD,wBAAgB,UAAU,CAAC,GAAG,WAAW,EAAE,cAAc,EAAE,YA1B/C,GAAG,gBACG,MAAM,GAAG,MAAM,eAChB,kBAAkB,UA0BlC"}