quantum-flow 1.0.1

package/dist/app/http/decorators.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Server = Server;
+exports.Use = Use;
+exports.Intercept = Intercept;
+exports.Catch = Catch;
+exports.Port = Port;
+exports.Host = Host;
+const _constants_1 = require("@constants");
+function Server(config = {}) {
+    return function (target) {
+        const existingConfig = Reflect.getMetadata(_constants_1.SERVER_CONFIG_KEY, target) || {};
+        const mergedConfig = {
+            ...existingConfig,
+            ...config,
+            controllers: [...(existingConfig.controllers || []), ...(config.controllers || [])],
+            globalMiddlewares: existingConfig.globalMiddlewares || config.globalMiddlewares,
+            globalInterceptors: existingConfig.globalInterceptors || config.globalInterceptors || [],
+        };
+        Reflect.defineMetadata(_constants_1.SERVER_CONFIG_KEY, mergedConfig, target);
+        if (config.controllers) {
+            Reflect.defineMetadata(_constants_1.SERVER_MODULES_KEY, config.controllers, target);
+        }
+        return target;
+    };
+}
+function Use(middleware) {
+    return function (target) {
+        const existingConfig = Reflect.getMetadata(_constants_1.SERVER_CONFIG_KEY, target) || {};
+        const middlewares = existingConfig.globalMiddlewares || [];
+        middlewares.push(middleware);
+        console.log(middlewares);
+        Reflect.defineMetadata(_constants_1.SERVER_CONFIG_KEY, {
+            ...existingConfig,
+            globalMiddlewares: middlewares,
+        }, target);
+        return target;
+    };
+}
+function Intercept(interceptor) {
+    return function (target) {
+        const existingConfig = Reflect.getMetadata(_constants_1.SERVER_CONFIG_KEY, target) || {};
+        const interceptors = existingConfig.globalInterceptors || [];
+        interceptors.push(interceptor);
+        Reflect.defineMetadata(_constants_1.SERVER_CONFIG_KEY, {
+            ...existingConfig,
+            globalInterceptors: interceptors,
+        }, target);
+        return target;
+    };
+}
+function Catch(handler) {
+    return function (target) {
+        const existingConfig = Reflect.getMetadata(_constants_1.SERVER_CONFIG_KEY, target) || {};
+        Reflect.defineMetadata(_constants_1.SERVER_CONFIG_KEY, {
+            ...existingConfig,
+            globalErrorHandler: handler,
+        }, target);
+        return target;
+    };
+}
+function Port(port) {
+    return function (target) {
+        const existingConfig = Reflect.getMetadata(_constants_1.SERVER_CONFIG_KEY, target) || {};
+        Reflect.defineMetadata(_constants_1.SERVER_CONFIG_KEY, {
+            ...existingConfig,
+            port,
+        }, target);
+        return target;
+    };
+}
+function Host(host) {
+    return function (target) {
+        const existingConfig = Reflect.getMetadata(_constants_1.SERVER_CONFIG_KEY, target) || {};
+        Reflect.defineMetadata(_constants_1.SERVER_CONFIG_KEY, {
+            ...existingConfig,
+            host,
+        }, target);
+        return target;
+    };
+}

package/dist/app/http/index.d.ts

@@ -0,0 +1,3 @@
+export * from './Application';
+export * from './decorators';
+export * from './websocket/WebsocketServer';

package/dist/app/http/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("./Application"), exports);
+__exportStar(require("./decorators"), exports);
+__exportStar(require("./websocket/WebsocketServer"), exports);

package/dist/app/http/websocket/WebsocetService.d.ts

@@ -0,0 +1,20 @@
+import { IWebSocketService } from '@types';
+import { WebSocketServer } from './WebsocketServer';
+export declare class WebSocketService implements IWebSocketService {
+    private static instance;
+    private wss;
+    private constructor();
+    static getInstance(): WebSocketService;
+    initialize(wss: WebSocketServer): void;
+    sendToClient(clientId: string, message: any): boolean;
+    publishToTopic(topic: string, data: any, exclude?: string[]): void;
+    broadcast(message: any, excludeClientId?: string): void;
+    getStats(): {
+        clients: number;
+        topics: {
+            topic: string;
+            subscribers: number;
+        }[];
+    };
+    isAvailable(): boolean;
+}

package/dist/app/http/websocket/WebsocetService.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketService = void 0;
+class WebSocketService {
+    static instance;
+    wss = null;
+    constructor() { }
+    static getInstance() {
+        if (!WebSocketService.instance) {
+            WebSocketService.instance = new WebSocketService();
+        }
+        return WebSocketService.instance;
+    }
+    initialize(wss) {
+        this.wss = wss;
+    }
+    sendToClient(clientId, message) {
+        if (!this.wss)
+            return false;
+        return this.wss.sendToClient(clientId, message);
+    }
+    publishToTopic(topic, data, exclude) {
+        if (!this.wss)
+            return;
+        this.wss.publishToTopic(topic, data, exclude);
+    }
+    broadcast(message, excludeClientId) {
+        if (!this.wss)
+            return;
+        this.wss.broadcast(message, excludeClientId);
+    }
+    getStats() {
+        if (!this.wss)
+            return { clients: 0, topics: [] };
+        return this.wss.getStats();
+    }
+    isAvailable() {
+        return this.wss !== null;
+    }
+}
+exports.WebSocketService = WebSocketService;

package/dist/app/http/websocket/WebsocketServer.d.ts

@@ -0,0 +1,30 @@
+import { WebSocketClient } from '@types';
+import http from 'http';
+export declare class WebSocketServer {
+    private wss;
+    private clients;
+    private topics;
+    private controllers;
+    private options;
+    constructor(server: http.Server, options?: any);
+    private shouldHandleWebSocket;
+    private ensureServer;
+    private handleConnection;
+    private handleMessage;
+    private handleClose;
+    private handleError;
+    private triggerHandlers;
+    registerControllers(controllers: any[]): void;
+    subscribeToTopic(client: WebSocketClient, topic: string): void;
+    unsubscribeFromTopic(client: WebSocketClient, topic: string): void;
+    publishToTopic(topic: string, data: any, exclude?: string[]): void;
+    sendToClient(clientId: string, message: any): boolean;
+    broadcast(message: any, excludeClientId?: string): void;
+    getStats(): {
+        clients: number;
+        topics: {
+            topic: string;
+            subscribers: number;
+        }[];
+    };
+}

package/dist/app/http/websocket/WebsocketServer.js

@@ -0,0 +1,221 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketServer = void 0;
+const uuid_1 = require("uuid");
+const ws_1 = __importDefault(require("ws"));
+class WebSocketServer {
+    wss = null;
+    clients = new Map();
+    topics = new Map();
+    controllers = [];
+    options;
+    constructor(server, options) {
+        this.options = options;
+        server.on('upgrade', (request, socket, head) => {
+            if (this.shouldHandleWebSocket(request.url)) {
+                this.ensureServer(server);
+                this.wss?.handleUpgrade(request, socket, head, (ws) => {
+                    this.wss?.emit('connection', ws, request);
+                });
+            }
+            else {
+                socket.destroy();
+            }
+        });
+    }
+    shouldHandleWebSocket(url = '') {
+        const path = this.options?.path || '/ws';
+        return url.startsWith(path);
+    }
+    ensureServer(server) {
+        if (!this.wss) {
+            this.wss = new ws_1.default.Server({
+                server,
+                path: this.options?.path || '/ws',
+                noServer: true,
+            });
+            this.wss.on('connection', (socket, request) => {
+                this.handleConnection(socket, request);
+            });
+        }
+    }
+    async handleConnection(socket, request) {
+        const clientId = (0, uuid_1.v4)();
+        const client = {
+            id: clientId,
+            socket,
+            topics: new Set(),
+            data: {},
+            connectedAt: new Date(),
+        };
+        this.clients.set(clientId, client);
+        socket.on('message', (data) => {
+            this.handleMessage(client, data);
+        });
+        socket.on('close', () => {
+            this.handleClose(client);
+        });
+        socket.on('error', (error) => {
+            this.handleError(client, error);
+        });
+        await this.triggerHandlers('connection', { type: 'connection', client });
+    }
+    async handleMessage(client, data) {
+        try {
+            const message = JSON.parse(data.toString());
+            if (message.type === 'subscribe' && message.topic) {
+                this.subscribeToTopic(client, message.topic);
+                return;
+            }
+            if (message.type === 'unsubscribe' && message.topic) {
+                this.unsubscribeFromTopic(client, message.topic);
+                return;
+            }
+            if (message.type === 'topic_message' && message.topic) {
+                await this.triggerHandlers('message', {
+                    type: 'message',
+                    client,
+                    message,
+                }, message.topic);
+                this.publishToTopic(message.topic, message.data, [client.id]);
+                return;
+            }
+            await this.triggerHandlers('message', {
+                type: 'message',
+                client,
+                message,
+            });
+        }
+        catch (error) {
+            client.socket.send(JSON.stringify({
+                type: 'error',
+                data: { message: 'Invalid message format' },
+            }));
+        }
+    }
+    async handleClose(client) {
+        client.topics.forEach((topic) => {
+            const topicClients = this.topics.get(topic);
+            if (topicClients) {
+                topicClients.delete(client.id);
+                if (topicClients.size === 0) {
+                    this.topics.delete(topic);
+                }
+            }
+        });
+        this.clients.delete(client.id);
+        await this.triggerHandlers('close', {
+            type: 'close',
+            client,
+        });
+    }
+    async handleError(client, error) {
+        await this.triggerHandlers('error', {
+            type: 'error',
+            client,
+            data: error,
+        });
+    }
+    async triggerHandlers(eventType, event, topic) {
+        for (const controller of this.controllers) {
+            const handlers = Reflect.getMetadata('websocket:handler', controller.constructor) || [];
+            const matchingHandlers = handlers.filter((h) => h.type === eventType && (!h.topic || h.topic === topic));
+            for (const handler of matchingHandlers) {
+                try {
+                    await controller[handler.method](event);
+                }
+                catch (error) {
+                    console.error(`Error in WebSocket handler ${handler.method}:`, error);
+                }
+            }
+            const subscriptions = Reflect.getMetadata('websocket:topic', controller.constructor) || [];
+            if (eventType === 'message' && topic) {
+                const matchingSubs = subscriptions.filter((s) => s.topic === topic);
+                for (const sub of matchingSubs) {
+                    try {
+                        await controller[sub.method](event);
+                    }
+                    catch (error) {
+                        console.error(`Error in subscription ${sub.method}:`, error);
+                    }
+                }
+            }
+        }
+    }
+    registerControllers(controllers) {
+        this.controllers = controllers;
+    }
+    subscribeToTopic(client, topic) {
+        if (!this.topics.has(topic)) {
+            this.topics.set(topic, new Set());
+        }
+        this.topics.get(topic).add(client.id);
+        client.topics.add(topic);
+        client.socket.send(JSON.stringify({
+            type: 'subscribed',
+            topic,
+            data: { success: true },
+        }));
+    }
+    unsubscribeFromTopic(client, topic) {
+        const topicClients = this.topics.get(topic);
+        if (topicClients) {
+            topicClients.delete(client.id);
+            if (topicClients.size === 0) {
+                this.topics.delete(topic);
+            }
+        }
+        client.topics.delete(topic);
+        client.socket.send(JSON.stringify({
+            type: 'unsubscribed',
+            topic,
+            data: { success: true },
+        }));
+    }
+    publishToTopic(topic, data, exclude) {
+        const topicClients = this.topics.get(topic);
+        if (!topicClients)
+            return;
+        const message = JSON.stringify({
+            type: 'message',
+            topic,
+            data,
+            timestamp: new Date().toISOString(),
+        });
+        topicClients.forEach((clientId) => {
+            const client = this.clients.get(clientId);
+            if (client && exclude?.includes(client.id)) {
+                client.socket.send(message);
+            }
+        });
+    }
+    sendToClient(clientId, message) {
+        const client = this.clients.get(clientId);
+        if (client) {
+            client.socket.send(JSON.stringify(message));
+            return true;
+        }
+        return false;
+    }
+    broadcast(message, excludeClientId) {
+        const messageStr = JSON.stringify(message);
+        this.clients.forEach((client, clientId) => {
+            if (clientId !== excludeClientId) {
+                client.socket.send(messageStr);
+            }
+        });
+    }
+    getStats() {
+        return {
+            clients: this.clients.size,
+            topics: Array.from(this.topics.entries()).map(([topic, clients]) => ({
+                topic,
+                subscribers: clients.size,
+            })),
+        };
+    }
+}
+exports.WebSocketServer = WebSocketServer;

package/dist/constants.d.ts

@@ -0,0 +1,16 @@
+export declare const PARAM_METADATA_KEY = "design:parameters";
+export declare const APP_METADATA_KEY = "app:configuration";
+export declare const ROUTE_PREFIX = "route:profix";
+export declare const MIDDLEWARES = "route:middlewares";
+export declare const CONTROLLERS = "app:controllers";
+export declare const INTERCEPTORS = "app:interceptors";
+export declare const ENDPOINT = "route:endpoints";
+export declare const OK_METADATA_KEY = "custom:ok";
+export declare const SERVER_CONFIG_KEY = "server:config";
+export declare const SERVER_MODULES_KEY = "server:modules";
+export declare const WS_METADATA_KEY = "websocket:handler";
+export declare const WS_TOPIC_KEY = "websocket:topic";
+export declare const WS_SERVICE_KEY = "websocket:service";
+export declare const STOPPED = "\n\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557\n\u2551  \uD83D\uDC4B Server stopped                      \u2551\n\u2551  \uD83D\uDCCA Status: STOPPED                      \u2551\n\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D\n          ";
+export declare const OK_STATUSES: number[];
+export declare const TO_VALIDATE: string[];

package/dist/constants.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TO_VALIDATE = exports.OK_STATUSES = exports.STOPPED = exports.WS_SERVICE_KEY = exports.WS_TOPIC_KEY = exports.WS_METADATA_KEY = exports.SERVER_MODULES_KEY = exports.SERVER_CONFIG_KEY = exports.OK_METADATA_KEY = exports.ENDPOINT = exports.INTERCEPTORS = exports.CONTROLLERS = exports.MIDDLEWARES = exports.ROUTE_PREFIX = exports.APP_METADATA_KEY = exports.PARAM_METADATA_KEY = void 0;
+exports.PARAM_METADATA_KEY = 'design:parameters';
+exports.APP_METADATA_KEY = 'app:configuration';
+exports.ROUTE_PREFIX = 'route:profix';
+exports.MIDDLEWARES = 'route:middlewares';
+exports.CONTROLLERS = 'app:controllers';
+exports.INTERCEPTORS = 'app:interceptors';
+exports.ENDPOINT = 'route:endpoints';
+exports.OK_METADATA_KEY = 'custom:ok';
+exports.SERVER_CONFIG_KEY = 'server:config';
+exports.SERVER_MODULES_KEY = 'server:modules';
+exports.WS_METADATA_KEY = 'websocket:handler';
+exports.WS_TOPIC_KEY = 'websocket:topic';
+exports.WS_SERVICE_KEY = 'websocket:service';
+exports.STOPPED = `
+╔════════════════════════════════════════╗
+║  👋 Server stopped                      ║
+║  📊 Status: STOPPED                      ║
+╚════════════════════════════════════════╝
+          `;
+exports.OK_STATUSES = [200, 201, 202, 203, 204, 205, 206, 207, 208, 226];
+exports.TO_VALIDATE = ['headers', 'params', 'multipart', 'query', 'body'];

package/dist/core/Controller.d.ts

@@ -0,0 +1,43 @@
+import { Interceptor, Middleware } from '@types';
+import { ServerResponse } from 'http';
+import 'reflect-metadata';
+type ControllerClass = {
+    new (...args: any[]): any;
+};
+type ControllerInstance = InstanceType<ControllerClass>;
+interface ControllerConfig {
+    prefix: string;
+    middlewares?: Array<Middleware>;
+    controllers?: ControllerClass[];
+    interceptors?: Array<(...args: any[]) => any> | ((...args: any[]) => any);
+}
+export declare function Controller(config: string | ControllerConfig, middlewares?: Array<Interceptor>): <T extends ControllerClass>(constructor: T) => {
+    new (...args: any[]): {
+        [x: string]: any;
+        executeControllerMethod: (controller: import("@types").ControllerInstance, propertyName: string, payload: any, response?: ServerResponse) => Promise<any>;
+        getControllerMethods: (controller: import("@types").ControllerInstance) => {
+            name: string;
+            httpMethod: string;
+            pattern: string;
+            middlewares?: Array<(req: any, res?: ServerResponse) => any>;
+        }[];
+        getResponse(data: {
+            controllerInstance: ControllerInstance;
+            name: string;
+            payload: any;
+            interceptors: Array<(...args: any[]) => any | Promise<any>>;
+            response?: ServerResponse;
+        }): Promise<{
+            status: any;
+            data: any;
+        }>;
+        handleRequest: (request: any, response?: ServerResponse) => Promise<{
+            status: any;
+            data: any;
+        } | {
+            status: number;
+            message: string;
+        }>;
+    };
+} & T;
+export {};

package/dist/core/Controller.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Controller = Controller;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const _constants_1 = require("@constants");
+const _utils_1 = require("@utils");
+require("reflect-metadata");
+function Controller(config, middlewares = []) {
+    // Handle both string and config object
+    const routePrefix = typeof config === 'string' ? config : config.prefix;
+    const controllers = typeof config === 'object' ? config.controllers : undefined;
+    const controllerMiddlewares = typeof config === 'object' ? [...(config.middlewares || []), ...middlewares] : middlewares;
+    const interceptors = typeof config === 'object'
+        ? config.interceptors
+            ? [].concat(config.interceptors)
+            : []
+        : [];
+    return function (constructor) {
+        const proto = constructor.prototype;
+        Reflect.defineMetadata(_constants_1.ROUTE_PREFIX, routePrefix, proto);
+        Reflect.defineMetadata(_constants_1.MIDDLEWARES, controllerMiddlewares, proto);
+        Reflect.defineMetadata(_constants_1.CONTROLLERS, controllers || [], proto);
+        Reflect.defineMetadata(_constants_1.INTERCEPTORS, interceptors, proto);
+        for (const key of Object.getOwnPropertyNames(proto)) {
+            if (key === 'constructor')
+                continue;
+            const descriptor = Object.getOwnPropertyDescriptor(proto, key);
+            if (!descriptor || typeof descriptor.value !== 'function')
+                continue;
+            const original = descriptor.value;
+            Object.defineProperty(proto, key, {
+                ...descriptor,
+                value: async function (...args) {
+                    try {
+                        return await original.apply(this, args);
+                    }
+                    catch (err) {
+                        return {
+                            status: err.status ?? 400,
+                            message: err.message,
+                            data: err,
+                        };
+                    }
+                },
+            });
+        }
+        return class extends constructor {
+            executeControllerMethod = _utils_1.executeControllerMethod;
+            getControllerMethods = _utils_1.getControllerMethods;
+            constructor(...args) {
+                super(...args);
+            }
+            async getResponse(data) {
+                try {
+                    let response = await this.executeControllerMethod(data.controllerInstance, data.name, data.payload, data.response);
+                    let status = response.status ?? 200;
+                    const isError = !_constants_1.OK_STATUSES.includes(status);
+                    for (let index = 0; index < data.interceptors?.length && !isError; index++) {
+                        const interceptor = data.interceptors[index];
+                        response = await interceptor(response);
+                    }
+                    const propertyName = data.name;
+                    const prototype = Object.getPrototypeOf(data.controllerInstance);
+                    const methodOkStatus = Reflect.getMetadata(_constants_1.OK_METADATA_KEY, data.controllerInstance, propertyName);
+                    if (methodOkStatus) {
+                        !isError && (status = methodOkStatus);
+                    }
+                    else {
+                        const classOkStatus = Reflect.getMetadata(_constants_1.OK_METADATA_KEY, prototype);
+                        !isError && classOkStatus && (status = classOkStatus);
+                    }
+                    return { status, data: response };
+                }
+                catch (err) {
+                    console.error(err);
+                    throw err;
+                }
+            }
+            handleRequest = async (request, response) => {
+                const method = request.method;
+                const path = (request.url.path ?? request.url.pathname ?? '').replace(/^\/+/, '');
+                const baseInterceptors = Reflect.getMetadata(_constants_1.INTERCEPTORS, proto);
+                const routePrefix = Reflect.getMetadata(_constants_1.ROUTE_PREFIX, proto) || '';
+                const middlewares = Reflect.getMetadata(_constants_1.MIDDLEWARES, proto) || [];
+                const subControllers = Reflect.getMetadata(_constants_1.CONTROLLERS, proto) || [];
+                // Try sub-controllers
+                for (const SubController of subControllers) {
+                    const controllerInstance = new SubController(SubController);
+                    if (!controllerInstance)
+                        continue;
+                    const subInterceptors = Reflect.getMetadata(_constants_1.INTERCEPTORS, controllerInstance);
+                    const controllerPrefix = Reflect.getMetadata(_constants_1.ROUTE_PREFIX, SubController.prototype) || '';
+                    const controllerMiddlewares = Reflect.getMetadata(_constants_1.MIDDLEWARES, SubController.prototype) || [];
+                    const methods = this.getControllerMethods(controllerInstance);
+                    for (const methodInfo of methods) {
+                        if (methodInfo.httpMethod === method || methodInfo.httpMethod === 'USE') {
+                            // Build full pattern: main prefix + controller prefix + method pattern
+                            const fullPattern = [routePrefix, controllerPrefix, methodInfo.pattern]
+                                .filter(Boolean)
+                                .join('/')
+                                .replace(/\/+/g, '/');
+                            const pathParams = (0, _utils_1.matchRoute)(fullPattern, path);
+                            if (pathParams) {
+                                let payload = { ...request, params: pathParams };
+                                // Apply all middlewares in order: main controller -> sub-controller -> method
+                                for (const middleware of [
+                                    ...middlewares,
+                                    ...controllerMiddlewares,
+                                    ...(methodInfo.middlewares || []),
+                                ]) {
+                                    const middlawareResponde = await middleware(payload, response);
+                                    payload = { ...payload, ...middlawareResponde };
+                                }
+                                return this.getResponse({
+                                    interceptors: [...subInterceptors, ...baseInterceptors],
+                                    controllerInstance,
+                                    name: methodInfo.name,
+                                    payload,
+                                    response,
+                                });
+                            }
+                        }
+                    }
+                }
+                const propertyNames = Object.getOwnPropertyNames(proto);
+                for (const propertyName of propertyNames) {
+                    const fn = this[propertyName];
+                    if (typeof fn !== 'function')
+                        continue;
+                    const endpointMeta = Reflect.getMetadata(_constants_1.ENDPOINT, proto, propertyName) || [];
+                    const [httpMethod, routePattern] = endpointMeta;
+                    if (httpMethod === method || httpMethod === 'USE') {
+                        const fullPattern = [routePrefix, routePattern]
+                            .filter(Boolean)
+                            .join('/')
+                            .replace(/\/+/g, '/');
+                        const pathParams = (0, _utils_1.matchRoute)(fullPattern, path);
+                        if (pathParams) {
+                            let payload = { ...request, params: pathParams };
+                            // Apply controller-level middlewares
+                            for (const middleware of middlewares) {
+                                const middlewareResponse = await middleware(payload);
+                                payload = { ...payload, middlewareResponse };
+                            }
+                            return this.getResponse({
+                                interceptors: baseInterceptors,
+                                controllerInstance: this,
+                                name: propertyName,
+                                payload,
+                                response,
+                            });
+                        }
+                    }
+                }
+                return { status: 404, message: 'Method Not Found' };
+            };
+        };
+    };
+}

package/dist/core/Endpoint.d.ts

@@ -0,0 +1,8 @@
+import { Middleware } from '@types';
+export declare function Endpoint(method: string, pathPattern?: string, middlewares?: Middleware[]): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare const GET: (pathPattern?: string, middelwares?: Middleware[]) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare const POST: (pathPattern?: string, middelwares?: Middleware[]) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare const PUT: (pathPattern?: string, middelwares?: Middleware[]) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare const PATCH: (pathPattern?: string, middelwares?: Middleware[]) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare const DELETE: (pathPattern?: string, middelwares?: Middleware[]) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare const USE: (pathPattern?: string, middelwares?: Middleware[]) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;