quantum-flow 1.0.6 → 1.1.0

package/dist/examples/controllers/socket.js

@@ -12,63 +12,22 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Socket = void 0;
 const core_1 = require("quantum-flow/core");
 let Socket = class Socket {
-    /**
-     * 1. Приветствие при подключении
-     */
     onConnection(event) {
-        console.log(`✅ Подключился: ${event.client.id}`);
-        // Отправляем приветствие ТОЛЬКО этому клиенту
-        event.client.socket.send(JSON.stringify({
-            type: 'welcome',
-            data: { message: 'Добро пожаловать!' },
-        }));
+        event.client.socket.send(JSON.stringify({ type: 'welcome', data: { message: 'welcome' } }));
     }
-    /**
-     * 2. @Subscribe - АВТОМАТИЧЕСКАЯ рассылка всем подписчикам
-     * Не нужно использовать WebSocketService!
-     */
     onChatMessage(event) {
-        // Этот метод вызывается для КАЖДОГО подписчика
-        // Сообщение УЖЕ автоматически разослано всем!
         const msg = event.message?.data;
-        console.log(`💬 Сообщение в chat: ${msg?.text}`);
-        // Можно добавить логику, но рассылать НЕ НУЖНО
-        if (msg?.text.includes('плохое')) {
-            // Если вернуть пустоту - сообщение не уйдет
+        if (msg?.text.includes('bad')) {
             return;
         }
-        // Всё, сообщение само уйдет подписчикам!
     }
-    /**
-     * 3. @Subscribe для другой комнаты
-     */
-    onNewsMessage(event) {
-        console.log(`📰 Новость: ${event.message?.data.title}`);
-        // Автоматическая рассылка всем подписанным на 'news'
-    }
-    /**
-     * 4. @OnMessage для команд (без WebSocketService)
-     */
+    onNewsMessage(event) { }
     onPing(event) {
-        // Отправляем ответ только этому клиенту
-        event.client.socket.send(JSON.stringify({
-            type: 'pong',
-            data: { time: Date.now() },
-        }));
+        event.client.socket.send(JSON.stringify({ type: 'pong', data: { time: Date.now() } }));
     }
-    /**
-     * 5. @OnMessage для подписки
-     */
     onSubscribe(event) {
         const topic = event.message?.data.topic;
-        console.log(`📌 Клиент ${event.client.id} подписался на ${topic}`);
-        // Сервер сам сохранит подписку, ничего делать не нужно!
-        // Просто подтверждаем
-        event.client.socket.send(JSON.stringify({
-            type: 'subscribed',
-            topic,
-            data: { success: true },
-        }));
+        event.client.socket.send(JSON.stringify({ type: 'subscribed', topic, data: { success: true } }));
     }
 };
 exports.Socket = Socket;

package/dist/examples/controllers/user.d.ts

@@ -1,3 +1,15 @@
+import { IWebSocketService } from 'quantum-flow/core';
+declare class DTO {
+    constructor();
+    name: string;
+}
 export declare class User {
-    test(body: any, query: any, headers: any, ws: any, resp: any): Promise<string>;
+    createUser(body: DTO, query: any, headers: any, ws: IWebSocketService, req: any, params: any, resp: any): Promise<{
+        body: DTO;
+        query: any;
+        headers: any;
+        params: any;
+    }>;
+    any(resp: any): Promise<string>;
 }
+export {};

package/dist/examples/controllers/user.js

@@ -15,7 +15,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.User = void 0;
 const class_validator_1 = require("class-validator");
 const core_1 = require("quantum-flow/core");
-const http_1 = require("quantum-flow/http");
+const userMetadata_1 = require("./userMetadata");
 class DTO {
     constructor() { }
     name;
@@ -25,31 +25,45 @@ __decorate([
     __metadata("design:type", String)
 ], DTO.prototype, "name", void 0);
 let User = class User {
-    async test(body, query, headers, ws, resp) {
-        console.log(resp.setHeader);
-        resp.setHeader('Set-Cookie', ['token=; Path=/; Max-Age=0', 'userId=; Path=/; Max-Age=0']);
-        return 'Test';
+    async createUser(body, query, headers, ws, req, params, resp) {
+        return { body, query, headers, params };
+    }
+    async any(resp) {
+        return 'done';
     }
 };
 exports.User = User;
 __decorate([
-    (0, core_1.Status)(300),
-    (0, core_1.USE)('/:nane'),
+    (0, core_1.Status)(201),
+    (0, core_1.PUT)(':id'),
     __param(0, (0, core_1.Body)(DTO)),
     __param(1, (0, core_1.Query)()),
     __param(2, (0, core_1.Headers)()),
     __param(3, (0, core_1.InjectWS)()),
-    __param(4, (0, core_1.Response)()),
+    __param(4, (0, core_1.Request)()),
+    __param(5, (0, core_1.Params)()),
+    __param(6, (0, core_1.Response)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [DTO, Object, Object, Object, Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], User.prototype, "createUser", null);
+__decorate([
+    (0, core_1.Status)(300),
+    (0, core_1.USE)(),
+    __param(0, (0, core_1.Response)()),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object, Object, Object, Object]),
+    __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", Promise)
-], User.prototype, "test", null);
+], User.prototype, "any", null);
 exports.User = User = __decorate([
     (0, core_1.Controller)({
         prefix: 'user',
+        controllers: [userMetadata_1.UserMetadata],
+        interceptor: (data, req, res) => {
+            return { data, intercepted: true };
+        },
     }),
-    (0, http_1.Intercept)(() => {
-        console.log('user interceptor');
-        return 'intercepted';
+    (0, core_1.Catch)((err) => {
+        return { status: 401, err };
     })
 ], User);

package/dist/examples/controllers/userMetadata.d.ts

@@ -0,0 +1,3 @@
+export declare class UserMetadata {
+    getUserMetadata(params: any): Promise<any>;
+}

package/dist/examples/controllers/userMetadata.js

@@ -0,0 +1,32 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserMetadata = void 0;
+const core_1 = require("quantum-flow/core");
+let UserMetadata = class UserMetadata {
+    async getUserMetadata(params) {
+        return params;
+    }
+};
+exports.UserMetadata = UserMetadata;
+__decorate([
+    (0, core_1.GET)('/:name'),
+    __param(0, (0, core_1.Params)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], UserMetadata.prototype, "getUserMetadata", null);
+exports.UserMetadata = UserMetadata = __decorate([
+    (0, core_1.Controller)({ prefix: 'metadata' })
+], UserMetadata);

package/dist/examples/server.js

@@ -9,40 +9,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("quantum-flow/core");
 const http_1 = require("quantum-flow/http");
 require("reflect-metadata");
-const socket_1 = require("./controllers/socket");
 const user_1 = require("./controllers/user");
 let Root = class Root {
 };
 Root = __decorate([
-    (0, core_1.Controller)({
-        prefix: 'api',
-        controllers: [user_1.User, socket_1.Socket],
-        interceptors: [
-            (resp) => {
-                return resp;
-            },
-        ],
-    })
+    (0, core_1.Controller)({ prefix: 'api', controllers: [user_1.User] })
 ], Root);
 let App = class App {
 };
 App = __decorate([
     (0, http_1.Server)({
         controllers: [Root],
-        websocket: {
-            enabled: true,
-        },
+        websocket: { enabled: true },
+        interceptor: (data) => data,
     }),
     (0, http_1.Port)(3000),
-    (0, http_1.Host)('localhost'),
-    (0, http_1.Use)((res) => res),
-    (0, http_1.Intercept)((data, req, res) => {
-        console.log(data, 'aaaaa', req);
-        return data;
-    }),
-    (0, http_1.Catch)((r) => {
-        return r;
-    })
+    (0, core_1.Use)((data) => data),
+    (0, core_1.Use)((data) => data),
+    (0, core_1.Catch)((error) => ({ status: 400, error }))
 ], App);
 const server = new http_1.HttpServer(App);
 server.listen().catch(console.error);

package/dist/types/common.d.ts

@@ -1,15 +1,18 @@
-import { IncomingHttpHeaders, ServerResponse } from 'http';
+import { IncomingHttpHeaders, IncomingMessage, ServerResponse } from 'http';
 type P_Q = Record<string, string | undefined> | null | unknown;
-export type Request<B = unknown, Q extends P_Q = unknown, P extends P_Q = unknown> = {
-    method: string;
+export type AppRequest<B = unknown, Q extends P_Q = unknown, P extends P_Q = unknown> = {
+    method: HTTP_METHODS;
     url: URL;
     headers: IncomingHttpHeaders;
     query?: Q;
     params?: P;
     body: B;
+    rawBody: Buffer<ArrayBufferLike>;
     isBase64Encoded?: boolean;
+    cookies: Record<string, string>;
+    _startTime: number;
 };
-export type Router = (req: Request, res?: ServerResponse) => Promise<{
+export type Router = (req: AppRequest, res?: ServerResponse) => Promise<{
     status: number;
     data: any;
     message?: string;
@@ -35,13 +38,34 @@ export type AxiosQuery = {
 export interface IController {
     handleRequest: Router;
 }
-export type Middleware = (req: Request, res?: ServerResponse) => Promise<Request> | Request;
-export type Interceptor = (data: any, req?: Request, res?: ServerResponse) => Promise<unknown> | unknown;
-export type ParamDecoratorType = 'body' | 'params' | 'query' | 'request' | 'headers' | 'cookies' | 'response' | 'multipart';
+export type MiddlewareCB = (appRequest: AppRequest, request?: IncomingMessage, respinse?: ServerResponse) => Promise<AppRequest> | AppRequest;
+export type InterceptorCB = (data: any, req?: IncomingMessage, res?: ServerResponse) => Promise<unknown> | unknown;
+export type ErrorCB = (error: Error, req?: IncomingMessage, res?: ServerResponse) => Promise<ResponseWithStatus> | ResponseWithStatus;
+export type ParamDecoratorType = 'body' | 'params' | 'query' | 'request' | 'headers' | 'cookies' | 'response' | 'multipart' | 'event' | 'context';
 export interface ParamMetadata {
     index: number;
     type: ParamDecoratorType;
     dto?: any;
     name?: string;
 }
+export interface ParamMetadata {
+    index: number;
+    type: ParamDecoratorType;
+    dto?: any;
+    name?: string;
+}
+export type ResponseWithStatus = {
+    status: number;
+    [key: string]: any;
+};
+export declare enum HTTP_METHODS {
+    USE = "USE",
+    GET = "GET",
+    POST = "POST",
+    PATCH = "PATCH",
+    DELETE = "DELETE",
+    PUT = "PUT",
+    OPTIONS = "OPTIONS",
+    HEAD = "HEAD"
+}
 export {};

package/dist/types/common.js

@@ -1,2 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.HTTP_METHODS = void 0;
+var HTTP_METHODS;
+(function (HTTP_METHODS) {
+    HTTP_METHODS["USE"] = "USE";
+    HTTP_METHODS["GET"] = "GET";
+    HTTP_METHODS["POST"] = "POST";
+    HTTP_METHODS["PATCH"] = "PATCH";
+    HTTP_METHODS["DELETE"] = "DELETE";
+    HTTP_METHODS["PUT"] = "PUT";
+    HTTP_METHODS["OPTIONS"] = "OPTIONS";
+    HTTP_METHODS["HEAD"] = "HEAD";
+})(HTTP_METHODS || (exports.HTTP_METHODS = HTTP_METHODS = {}));

package/dist/types/controller.d.ts

@@ -1,4 +1,37 @@
+import { IncomingMessage, ServerResponse } from 'http';
+import { AppRequest, ErrorCB, HTTP_METHODS, InterceptorCB, MiddlewareCB } from './common';
 export type ControllerClass = {
     new (...args: any[]): any;
 };
 export type ControllerInstance = InstanceType<ControllerClass>;
+export type ControllerMethods = Array<{
+    name: string;
+    httpMethod: HTTP_METHODS;
+    pattern: string;
+    middlewares?: MiddlewareCB[];
+}>;
+export type ControllerMetadata = {
+    routePrefix: string;
+    middlewares: MiddlewareCB[];
+    interceptor?: InterceptorCB;
+    subControllers: ControllerClass[];
+    errorHandler?: ErrorCB;
+};
+export interface ControllerConfig {
+    prefix: string;
+    middlewares?: Array<MiddlewareCB>;
+    controllers?: ControllerClass[];
+    interceptor?: InterceptorCB;
+}
+export type RouteContext = {
+    controllerInstance: any;
+    controllerMeta: ControllerMetadata;
+    path: string;
+    method: string;
+    appRequest: AppRequest;
+    request?: IncomingMessage;
+    response?: ServerResponse;
+    middlewareChain: MiddlewareCB[];
+    interceptorChain: InterceptorCB[];
+    subPath: string;
+};

package/dist/types/http.d.ts

@@ -1,18 +1,14 @@
+import { ErrorCB, InterceptorCB, MiddlewareCB } from './common';
 export interface ServerConfig {
     port?: number;
     host?: string;
-    globalMiddlewares?: any[];
-    globalInterceptors?: any[];
-    globalErrorHandler?: any;
-    controllers?: any[];
+    middlewares?: MiddlewareCB[];
+    interceptor?: InterceptorCB;
+    errorHandler?: ErrorCB;
+    controllers?: (new (...args: any[]) => any)[];
     websocket?: {
         enabled: boolean;
         path?: string;
         lazy?: boolean;
     };
 }
-export type Conf = ServerConfig & {
-    globalMiddlewares?: any[];
-    globalInterceptors?: any[];
-    globalErrorHandler?: any;
-};

package/dist/types/lambda.d.ts

@@ -7,7 +7,6 @@ export interface LambdaRequest {
     body: any;
     params: Record<string, string>;
     cookies: Record<string, string>;
-    raw: APIGatewayProxyEvent;
     context: Context;
     isBase64Encoded: boolean;
     requestId: string;
@@ -15,6 +14,7 @@ export interface LambdaRequest {
     sourceIp: string;
     userAgent: string;
     url: URL;
+    event: APIGatewayProxyEvent;
 }
 export interface LambdaResponse {
     statusCode: number;
@@ -24,3 +24,10 @@ export interface LambdaResponse {
     multiValueHeaders?: Record<string, string[]>;
     cookies?: string[];
 }
+export interface LambdaApp {
+    beforeStart?: () => void;
+}
+export interface Lambda {
+    beforeStart?: () => Promise<void>;
+    handleRequest(request: any): Promise<any>;
+}

package/dist/utils/controller.d.ts

@@ -1,9 +1,4 @@
-import { ControllerInstance } from '../types/index.js';
-import { ServerResponse } from 'http';
-export declare const executeControllerMethod: (controller: ControllerInstance, propertyName: string, payload: any, response?: ServerResponse) => Promise<any>;
-export declare const getControllerMethods: (controller: ControllerInstance) => {
-    name: string;
-    httpMethod: string;
-    pattern: string;
-    middlewares?: Array<(req: any, res?: ServerResponse) => any>;
-}[];
+import { ControllerInstance, ControllerMethods } from '../types/index.js';
+import { IncomingMessage, ServerResponse } from 'http';
+export declare const executeControllerMethod: (controller: ControllerInstance, propertyName: string, payload: any, request?: IncomingMessage, response?: ServerResponse) => Promise<any>;
+export declare const getControllerMethods: (controller: ControllerInstance) => ControllerMethods;

package/dist/utils/controller.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getControllerMethods = exports.executeControllerMethod = void 0;
+const _types_1 = require("../types/index.js");
 const _utils_1 = require("./index.js");
 const WebsocetService_1 = require("../app/http/websocket/WebsocetService");
 const validate_1 = require("./validate");
@@ -25,7 +26,7 @@ const getBodyAndMultipart = (payload) => {
     }
     return { multipart, body };
 };
-const executeControllerMethod = async (controller, propertyName, payload, response) => {
+const executeControllerMethod = async (controller, propertyName, payload, request, response) => {
     const fn = controller[propertyName];
     if (typeof fn !== 'function')
         return null;
@@ -67,15 +68,15 @@ const executeControllerMethod = async (controller, propertyName, payload, respon
         if (param.type === 'request') {
             value = payload;
         }
-        if (param.type === 'response') {
-            value = response;
-        }
-        if (param.type === 'response') {
-            value = response;
+        if (param.type === 'request') {
+            value = request;
         }
         if (param.type === 'body') {
             value = body;
         }
+        if (param.type === 'response') {
+            value = response;
+        }
         if (_constants_1.TO_VALIDATE.includes(param.type)) {
             value = await (0, validate_1.validate)(param.dto, value);
         }
@@ -106,6 +107,6 @@ const getControllerMethods = (controller) => {
         }
         proto = Object.getPrototypeOf(proto);
     }
-    return methods;
+    return methods.sort((a, b) => (a.httpMethod === _types_1.HTTP_METHODS.USE ? 1 : -1));
 };
 exports.getControllerMethods = getControllerMethods;

package/dist/utils/endpoint.d.ts

@@ -0,0 +1,2 @@
+import { ParamDecoratorType } from '../types/index.js';
+export declare function createParamDecorator(type: ParamDecoratorType, dto?: any, name?: string): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;

package/dist/utils/endpoint.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createParamDecorator = createParamDecorator;
+const _constants_1 = require("../constants.js");
+function createParamDecorator(type, dto, name) {
+    return function (target, propertyKey, parameterIndex) {
+        const existingParams = Reflect.getMetadata(_constants_1.PARAM_METADATA_KEY, target, propertyKey) || [];
+        existingParams.push({ index: parameterIndex, type, dto, name });
+        existingParams.sort((a, b) => a.index - b.index);
+        Reflect.defineMetadata(_constants_1.PARAM_METADATA_KEY, existingParams, target, propertyKey);
+        const saved = Reflect.getMetadata(_constants_1.PARAM_METADATA_KEY, target, propertyKey);
+    };
+}

package/dist/utils/helper.d.ts

@@ -1 +1,5 @@
-export declare const matchRoute: (routePattern: string, actualPath: string) => Record<string, string> | null;
+import { InterceptorCB, MiddlewareCB } from '../types/index.js';
+export declare function matchRoute(pattern: string, path: string): Record<string, string> | null;
+export declare function buildRoutePattern(parts: string[]): string;
+export declare function mergeMiddlewares(...middlewareLists: MiddlewareCB[][]): MiddlewareCB[];
+export declare function mergeInterceptors(...interceptorLists: InterceptorCB[][]): InterceptorCB[];

package/dist/utils/helper.js

@@ -1,24 +1,61 @@
 "use strict";
-/* eslint-disable @typescript-eslint/no-explicit-any */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.matchRoute = void 0;
-const matchRoute = (routePattern, actualPath) => {
-    const routeParts = routePattern.split('/').filter(Boolean);
-    const pathParts = actualPath.split('/').filter(Boolean);
-    if (routeParts.length !== pathParts.length)
-        return null;
+exports.matchRoute = matchRoute;
+exports.buildRoutePattern = buildRoutePattern;
+exports.mergeMiddlewares = mergeMiddlewares;
+exports.mergeInterceptors = mergeInterceptors;
+function matchRoute(pattern, path) {
+    pattern = pattern.replace(/^\/+|\/+$/g, '');
+    path = path.replace(/^\/+|\/+$/g, '');
+    const patternSegments = pattern.split('/').filter(Boolean);
+    const pathSegments = path.split('/').filter(Boolean);
     const params = {};
-    for (let i = 0; i < routeParts.length; i++) {
-        const routePart = routeParts[i];
-        const pathPart = pathParts[i];
-        if (routePart.startsWith(':')) {
-            const paramName = routePart.slice(1);
-            params[paramName] = decodeURIComponent(pathPart);
+    let i = 0;
+    let j = 0;
+    while (i < patternSegments.length && j < pathSegments.length) {
+        const patternSegment = patternSegments[i];
+        const pathSegment = pathSegments[j];
+        if (patternSegment === '*') {
+            params['*'] = pathSegments.slice(j).join('/');
+            return params;
+        }
+        if (patternSegment.startsWith(':')) {
+            const paramName = patternSegment.slice(1);
+            params[paramName] = pathSegment;
+            i++;
+            j++;
+            continue;
         }
-        else if (routePart !== pathPart) {
+        if (patternSegment !== pathSegment) {
             return null;
         }
+        i++;
+        j++;
     }
-    return params;
-};
-exports.matchRoute = matchRoute;
+    while (i < patternSegments.length) {
+        const patternSegment = patternSegments[i];
+        if (patternSegment === '*') {
+            params['*'] = '';
+            i++;
+        }
+        else if (patternSegment.startsWith(':')) {
+            return null;
+        }
+        else {
+            return null;
+        }
+    }
+    if (j < pathSegments.length) {
+        return null;
+    }
+    return Object.keys(params).length > 0 ? params : {};
+}
+function buildRoutePattern(parts) {
+    return parts.filter(Boolean).join('/').replace(/\/+/g, '/');
+}
+function mergeMiddlewares(...middlewareLists) {
+    return middlewareLists.flat();
+}
+function mergeInterceptors(...interceptorLists) {
+    return interceptorLists.flat();
+}

package/dist/utils/index.d.ts

@@ -5,3 +5,4 @@ export * from './parsers';
 export * from './server';
 export * from './transform';
 export * from './validate';
+export * from './endpoint';

package/dist/utils/index.js

@@ -21,3 +21,4 @@ __exportStar(require("./parsers"), exports);
 __exportStar(require("./server"), exports);
 __exportStar(require("./transform"), exports);
 __exportStar(require("./validate"), exports);
+__exportStar(require("./endpoint"), exports);

package/dist/utils/server.js

@@ -7,10 +7,14 @@ const resolveConfig = (configOrClass) => {
     if (configOrClass && typeof configOrClass === 'function') {
         const decoratorConfig = Reflect.getMetadata(_constants_1.SERVER_CONFIG_KEY, configOrClass) || {};
         const controllers = Reflect.getMetadata(_constants_1.SERVER_MODULES_KEY, configOrClass) || [];
+        const errorHandler = Reflect.getMetadata(_constants_1.CATCH, configOrClass);
+        const interceptors = Reflect.getMetadata(_constants_1.INTECEPT, configOrClass);
         config = {
             port: 3000,
             host: 'localhost',
             ...decoratorConfig,
+            errorHandler,
+            interceptors,
             controllers: [...controllers, ...(decoratorConfig.controllers || [])],
         };
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "quantum-flow",
-  "version": "1.0.6",
+  "version": "1.1.0",
   "description": "Decorator-based API framework",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",