quantum-flow 1.4.0 → 1.5.0

package/README.md

@@ -20,6 +20,7 @@ You can use controllers and server functionality by importing controllers and cr
 - `quantum-flow/http` - Main application source code for HTTP servers.
 - `quantum-flow/aws` - Main application source code AWS Lambda.
 - `quantum-flow/core` - Core framework components like Controller and Endpoint.
+- `quantum-flow/middlewares` - Core middlewares to use within the application.
 
 ---
 
@@ -30,7 +31,6 @@ Use the `@Controller` decorator to define controllers with options such as prefi
 ```typescript
 import {
   Body,
-  Catch,
   Controller,
   Headers,
   InjectWS,
@@ -42,9 +42,9 @@ import {
   Response,
   Status,
   USE,
-  CORS
 } from 'quantum-flow/core';
 import {IsString} from  'class-validator'
+import { Catch, Cors, Sanitize, Use } from 'quantum-flow/middlewares';
 
 class UserDto {
   constructor() {}
@@ -55,16 +55,24 @@ class UserDto {
 @Controller({
   prefix: 'user',
   controllers: [UserMetadata, ...],
-  interceptor: (data, req, res) => {
-    return { data, intercepted: true };
-  },
+  interceptor: (data, req, res) => data,
 })
-@CORS({ origin: '*' })
+@Cors({ origin: '*' })
 @Catch((err) => ({ status: 500, err }))
+@Use(()=>{})
+@Sanitize({
+  schema: Joi.object({
+    name: Joi.string().trim().min(2).max(50).required(),
+  }),
+  action: 'both',
+  options: { abortEarly: false },
+  stripUnknown: true,
+  type: 'body',
+})
 export class User {
   @Status(201)
-  @PUT(':id',[...middlewares])
-  @CORS({ origin: '*' })
+  @PUT(':id',[(req, res)=>{} , ...middlewares])
+  @Cors({ origin: '*' })
   async createUser(
     @Body(UserDto) body: UserDto,
     @Query() query: any,
@@ -87,7 +95,7 @@ export class User {
   prefix: 'api',
   controllers: [UserController, SocketController],
   middelwares: [...middlewares],
-  interceptor: (parsedRequest, httpRequest, httpResponse) => parsedRequest,
+  interceptor: (data, req, res) => data,
 })
 @Catch((error) => ({ status: 400, error }))
 class RootController {}
@@ -104,7 +112,6 @@ import { Server, Port, Host, Use, Catch, HttpServer } from 'quantum-flow/http';
 @Port(3000)
 @Host('localhost')
 @Use((data) => data)
-@Use((data) => data)
 @Catch((error) => ({ status: 400, error }))
 class App {}
 
@@ -118,7 +125,8 @@ server.listen().catch(console.error);
 - Use `@Use` to apply middlewares.
 - Use `@Catch` to handle errors.
 - Use `@Port` and `@Host` to configure server port and host.
-- Use `@CORS` to configure cors.
+- Use `@Cors` to configure cors.
+- Use `@Sanitize` to apply sanitization to reqest.
 
 ## Request decorators
 
@@ -239,6 +247,7 @@ export class Socket {
 ### Use
 
 Class decorator to add global middlewares to the server.
+Should be used only with @Server decorator
 
 ```typescript
 @Use(middleware)

package/dist/app/aws/lambda.d.ts

@@ -2,9 +2,6 @@ import { LambdaApp } from '../../types/index.js';
 import { Handler } from 'aws-lambda';
 export declare class LambdaAdapter {
     static createHandler(Controller: new (...args: any[]) => LambdaApp): Handler;
-    private static getEventType;
-    private static toRequest;
     private static toLambdaResponse;
     private static handleError;
-    private static getSourceIp;
 }

package/dist/app/aws/lambda.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LambdaAdapter = void 0;
 const _constants_1 = require("../../constants.js");
 const _utils_1 = require("../../utils/index.js");
-const helpers_1 = require("./helpers");
+const utils_1 = require("./utils");
 class LambdaAdapter {
     static createHandler(Controller) {
         return async (event, context) => {
@@ -11,126 +11,39 @@ class LambdaAdapter {
             if (Object.hasOwn(instance, 'beforeStart')) {
                 await instance.beforeStart?.();
             }
+            const eventType = (0, utils_1.getEventType)(event);
             try {
                 const cors = Reflect.getMetadata(_constants_1.CORS_METADATA, instance);
-                const eventType = this.getEventType(event);
-                const normalizedEvent = (0, _utils_1.normalizeEvent)(event, eventType);
-                const request = this.toRequest(normalizedEvent, context);
-                const lambdaRequest = new helpers_1.LRequest(request);
-                const lambdaResponse = new helpers_1.LResponse();
+                const request = new utils_1.LRequest(event, context);
+                const response = new utils_1.LResponse();
                 let handledCors = { permitted: true, continue: true };
                 if (cors) {
-                    handledCors = (0, _utils_1.handleCORS)(request, lambdaResponse, cors);
+                    handledCors = (0, _utils_1.handleCORS)(request, response, cors);
                 }
                 if (!handledCors.permitted) {
-                    return this.toLambdaResponse({ status: 403, message: 'CORS: Origin not allowed' }, lambdaRequest, lambdaResponse, eventType);
+                    return this.toLambdaResponse({ status: 403, message: 'Cors: Origin not allowed' }, request, response, eventType);
                 }
                 if (!handledCors.continue && handledCors.permitted) {
-                    return this.toLambdaResponse({ status: 204 }, lambdaRequest, lambdaResponse, eventType);
+                    return this.toLambdaResponse({ status: 204 }, request, response, eventType);
                 }
                 if (typeof instance.handleRequest !== 'function') {
                     throw new Error('Controller must have handleRequest method');
                 }
-                const response = await instance.handleRequest(request, lambdaRequest, lambdaResponse);
-                return this.toLambdaResponse(response, lambdaRequest, lambdaResponse, eventType);
+                const data = await instance.handleRequest(request, response);
+                return this.toLambdaResponse(data, request, response, eventType);
             }
             catch (error) {
                 return this.handleError(error, event, context);
             }
         };
     }
-    static getEventType(event) {
-        if (event.httpMethod && event.resource) {
-            return 'rest';
-        }
-        if (event.version === '2.0' || event.requestContext?.http) {
-            return 'http';
-        }
-        if (event.version && event.rawPath && !event.requestContext?.http) {
-            return 'url';
-        }
-        return 'rest';
-    }
-    static toRequest(event, context) {
-        const query = {};
-        if (event.multiValueQueryStringParameters) {
-            Object.entries(event.multiValueQueryStringParameters).forEach(([key, value]) => {
-                query[key] = value;
-            });
-        }
-        else {
-            Object.entries(event.queryStringParameters).forEach(([key, value]) => {
-                query[key] = value;
-            });
-        }
-        const cookies = {};
-        const cookieHeader = event.headers?.Cookie || event.headers?.cookie || event.headers?.cookies;
-        if (cookieHeader) {
-            if (Array.isArray(cookieHeader)) {
-                cookieHeader.forEach((cookie) => {
-                    const [name, value] = cookie.split('=');
-                    if (name && value)
-                        cookies[name] = decodeURIComponent(value);
-                });
-            }
-            else {
-                cookieHeader.split(';').forEach((cookie) => {
-                    const [name, value] = cookie.trim().split('=');
-                    if (name && value)
-                        cookies[name] = decodeURIComponent(value);
-                });
-            }
-        }
-        let rawBody = Buffer.from(event.body ?? '', 'base64');
-        let body = event.body || {};
-        if (event.body && event.isBase64Encoded) {
-            body = rawBody.toString('utf-8');
-        }
-        if (typeof body === 'string' && body.trim().startsWith('{')) {
-            try {
-                body = JSON.parse(body);
-            }
-            catch (e) { }
-        }
-        const xForvarded = Array.isArray(event.headers['x-forwarded-proto'])
-            ? event.headers['x-forwarded-proto']?.[0]
-            : event.headers['x-forwarded-proto'];
-        const xhost = Array.isArray(event.headers['host'])
-            ? event.headers['host']?.[0]
-            : event.headers['host'];
-        const protocol = xForvarded || 'https';
-        const host = xhost || 'localhost:3000';
-        const fullUrl = `${protocol}://${host}${event.path}`;
-        let url = new URL(fullUrl);
-        return {
-            method: event.httpMethod.toUpperCase(),
-            url,
-            headers: event.headers,
-            query,
-            body,
-            params: event.pathParameters,
-            cookies,
-            event,
-            context,
-            rawBody,
-            path: event.path,
-            isBase64Encoded: event.isBase64Encoded,
-            requestId: context.awsRequestId,
-            stage: event.requestContext?.stage || '$default',
-            sourceIp: this.getSourceIp(event),
-            _startTime: Date.now(),
-            userAgent: typeof event.headers['user-agent'] === 'string'
-                ? event.headers['user-agent']
-                : event.headers['user-agent']?.[0] || 'unknown',
-        };
-    }
-    static toLambdaResponse(appResponse, request, res, eventType) {
-        const statusCode = appResponse.status || 200;
+    static toLambdaResponse(data, request, response, eventType) {
+        const statusCode = data.status || 200;
         const headers = {
             'Content-Type': 'application/json',
             'X-Request-Id': request.requestId,
-            ...(appResponse.headers || {}),
-            ...res.headers,
+            ...(data.headers || {}),
+            ...response.headers,
         };
         const originHeader = request.headers['origin'] || request.headers['Origin'];
         let origin;
@@ -151,13 +64,13 @@ class LambdaAdapter {
         }
         const body = JSON.stringify({
             success: statusCode < 400,
-            data: appResponse.data,
+            data: data.data ?? data.error,
             timestamp: new Date().toISOString(),
         });
         const commonResponse = {
             statusCode,
             headers,
-            body: appResponse.data,
+            body: data.data ?? data.error,
             timestamp: new Date().toISOString(),
         };
         switch (eventType) {
@@ -186,7 +99,7 @@ class LambdaAdapter {
         }
     }
     static handleError(error, event, context) {
-        const eventType = this.getEventType(event);
+        const eventType = (0, utils_1.getEventType)(event);
         const statusCode = error.status || 500;
         const body = JSON.stringify({
             success: false,
@@ -215,21 +128,5 @@ class LambdaAdapter {
                 };
         }
     }
-    static getSourceIp(event) {
-        const forwardedFor = event.headers['x-forwarded-for'];
-        if (forwardedFor) {
-            if (Array.isArray(forwardedFor)) {
-                return forwardedFor[0].split(',')[0].trim();
-            }
-            return forwardedFor.split(',')[0].trim();
-        }
-        if (event.requestContext?.identity?.sourceIp) {
-            return event.requestContext.identity.sourceIp;
-        }
-        if (event.requestContext?.http?.sourceIp) {
-            return event.requestContext.http.sourceIp;
-        }
-        return '0.0.0.0';
-    }
 }
 exports.LambdaAdapter = LambdaAdapter;

package/dist/app/aws/utils/helpers.d.ts

@@ -0,0 +1,4 @@
+import { NormalizedEvent } from '../../../types/index.js';
+export declare const getEventType: (event: any) => "rest" | "http" | "url";
+export declare const getSourceIp: (event: NormalizedEvent) => string;
+export declare const normalizeEvent: (event: any, type: string) => NormalizedEvent;

package/dist/app/aws/utils/helpers.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeEvent = exports.getSourceIp = exports.getEventType = void 0;
+const getEventType = (event) => {
+    if (event.httpMethod && event.resource) {
+        return 'rest';
+    }
+    if (event.version === '2.0' || event.requestContext?.http) {
+        return 'http';
+    }
+    if (event.version && event.rawPath && !event.requestContext?.http) {
+        return 'url';
+    }
+    return 'rest';
+};
+exports.getEventType = getEventType;
+const getSourceIp = (event) => {
+    const forwardedFor = event.headers['x-forwarded-for'];
+    if (forwardedFor) {
+        if (Array.isArray(forwardedFor)) {
+            return forwardedFor[0].split(',')[0].trim();
+        }
+        return forwardedFor.split(',')[0].trim();
+    }
+    if (event.requestContext?.identity?.sourceIp) {
+        return event.requestContext.identity.sourceIp;
+    }
+    if (event.requestContext?.http?.sourceIp) {
+        return event.requestContext.http.sourceIp;
+    }
+    return '0.0.0.0';
+};
+exports.getSourceIp = getSourceIp;
+const parseQueryString = (queryString) => {
+    const params = {};
+    if (!queryString)
+        return params;
+    new URLSearchParams(queryString).forEach((value, key) => {
+        params[key] = value;
+    });
+    return params;
+};
+const normalizeEvent = (event, type) => {
+    const base = {
+        headers: event.headers || {},
+        body: event.body || null,
+        isBase64Encoded: event.isBase64Encoded || false,
+        requestContext: event.requestContext,
+    };
+    switch (type) {
+        case 'rest':
+            return {
+                ...base,
+                httpMethod: event.httpMethod,
+                path: event.path,
+                queryStringParameters: event.queryStringParameters || {},
+                multiValueQueryStringParameters: event.multiValueQueryStringParameters,
+                pathParameters: event.pathParameters || {},
+                cookies: event.headers?.Cookie ? [event.headers.Cookie] : [],
+            };
+        case 'http':
+            return {
+                ...base,
+                httpMethod: event.requestContext?.http?.method || 'GET',
+                path: event.rawPath,
+                queryStringParameters: event.queryStringParameters || {},
+                pathParameters: event.pathParameters || {},
+                cookies: event.cookies || [],
+            };
+        case 'url':
+            return {
+                ...base,
+                httpMethod: event.requestContext?.http?.method || 'GET',
+                path: event.rawPath,
+                queryStringParameters: parseQueryString(event.rawQueryString),
+                pathParameters: {},
+                cookies: [],
+            };
+        default:
+            throw new Error(`Unsupported event type: ${type}`);
+    }
+};
+exports.normalizeEvent = normalizeEvent;

package/dist/app/aws/utils/index.d.ts

@@ -0,0 +1,3 @@
+export * from './helpers';
+export * from './request';
+export * from './response';

package/dist/app/aws/utils/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("./helpers"), exports);
+__exportStar(require("./request"), exports);
+__exportStar(require("./response"), exports);

package/dist/app/aws/utils/request.d.ts

@@ -0,0 +1,23 @@
+import { HTTP_METHODS, LambdaEvent, MultipartFile } from '../../../types/index.js';
+import { Context } from 'aws-lambda';
+export declare class LRequest {
+    requestUrl: URL;
+    method: HTTP_METHODS;
+    path?: string;
+    headers: Record<string, string | string[]>;
+    query?: Record<string, string | string[]>;
+    params?: Record<string, string>;
+    body: any;
+    rawBody: Buffer<ArrayBufferLike>;
+    isBase64Encoded?: boolean;
+    cookies: Record<string, string>;
+    multipart?: Record<string, MultipartFile | MultipartFile[]>;
+    _startTime: number;
+    url: string;
+    requestId: string;
+    stage?: string;
+    userAgent: string;
+    sourceIp: string;
+    constructor(lambdaEvent: LambdaEvent, context: Context);
+    end(): void;
+}

package/dist/app/aws/utils/request.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LRequest = void 0;
+const helpers_1 = require("./helpers");
+class LRequest {
+    requestUrl;
+    method;
+    path;
+    headers;
+    query;
+    params;
+    body;
+    rawBody;
+    isBase64Encoded;
+    cookies;
+    multipart;
+    _startTime;
+    url;
+    requestId;
+    stage;
+    userAgent;
+    sourceIp;
+    constructor(lambdaEvent, context) {
+        const event = (0, helpers_1.normalizeEvent)(lambdaEvent, (0, helpers_1.getEventType)(lambdaEvent));
+        const query = {};
+        if (event.multiValueQueryStringParameters) {
+            Object.entries(event.multiValueQueryStringParameters).forEach(([key, value]) => {
+                query[key] = value;
+            });
+        }
+        else {
+            Object.entries(event.queryStringParameters).forEach(([key, value]) => {
+                query[key] = value;
+            });
+        }
+        const cookies = {};
+        const cookieHeader = event.headers?.Cookie || event.headers?.cookie || event.headers?.cookies;
+        if (cookieHeader) {
+            if (Array.isArray(cookieHeader)) {
+                cookieHeader.forEach((cookie) => {
+                    const [name, value] = cookie.split('=');
+                    if (name && value)
+                        cookies[name] = decodeURIComponent(value);
+                });
+            }
+            else {
+                cookieHeader.split(';').forEach((cookie) => {
+                    const [name, value] = cookie.trim().split('=');
+                    if (name && value)
+                        cookies[name] = decodeURIComponent(value);
+                });
+            }
+        }
+        let rawBody = Buffer.from(event.body ?? '', 'base64');
+        let body = event.body || {};
+        if (event.body && event.isBase64Encoded) {
+            body = rawBody.toString('utf-8');
+        }
+        if (typeof body === 'string' && body.trim().startsWith('{')) {
+            try {
+                body = JSON.parse(body);
+            }
+            catch (e) { }
+        }
+        const xForvarded = Array.isArray(event.headers['x-forwarded-proto'])
+            ? event.headers['x-forwarded-proto']?.[0]
+            : event.headers['x-forwarded-proto'];
+        const xhost = Array.isArray(event.headers['host'])
+            ? event.headers['host']?.[0]
+            : event.headers['host'];
+        const protocol = xForvarded || 'https';
+        const host = xhost || 'localhost:3000';
+        const fullUrl = `${protocol}://${host}${event.path}`;
+        let url = new URL(fullUrl);
+        this.method = event.httpMethod.toUpperCase();
+        this.url = fullUrl;
+        this.headers = event.headers;
+        this.cookies = cookies;
+        this.params = event.pathParameters;
+        this.rawBody = rawBody;
+        this.path = event.path;
+        this.isBase64Encoded = event.isBase64Encoded;
+        this.requestId = context.awsRequestId;
+        this.requestUrl = url;
+        this.stage = event.requestContext?.stage || '$default';
+        this.sourceIp = (0, helpers_1.getSourceIp)(event);
+        this.userAgent =
+            typeof event.headers['user-agent'] === 'string'
+                ? event.headers['user-agent']
+                : event.headers['user-agent']?.[0] || 'unknown';
+    }
+    end() {
+        console.log('NOT implemented for  lambda');
+    }
+}
+exports.LRequest = LRequest;

package/dist/app/aws/utils/response.d.ts

@@ -1,7 +1,14 @@
-import { AppRequest } from '../../../types/index.js';
-import { IncomingHttpHeaders } from 'http';
-export declare class Response {
-    headers: IncomingHttpHeaders;
-    constructor(request: AppRequest);
-    setHeader(header: string, value: string): void;
+import { ServerResponse } from 'http';
+export declare class LResponse {
+    private originalResponse?;
+    private _statusCode;
+    private _headers;
+    private _body;
+    constructor(originalResponse?: ServerResponse | undefined);
+    setHeader(name: string, value: string): void;
+    set statusCode(code: number);
+    get statusCode(): number;
+    get headers(): Record<string, string>;
+    send(): void;
+    get original(): ServerResponse | undefined;
 }

package/dist/app/aws/utils/response.js

@@ -1,13 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Response = void 0;
-class Response {
-    headers;
-    constructor(request) {
-        this.headers = { ...request.headers };
+exports.LResponse = void 0;
+class LResponse {
+    originalResponse;
+    _statusCode = 200;
+    _headers = {};
+    _body = null;
+    constructor(originalResponse) {
+        this.originalResponse = originalResponse;
     }
-    setHeader(header, value) {
-        this.headers[header] = value;
+    setHeader(name, value) {
+        this._headers[name] = value;
+        if (this.originalResponse) {
+            this.originalResponse.setHeader(name, value);
+        }
+    }
+    set statusCode(code) {
+        this._statusCode = code;
+        if (this.originalResponse) {
+            this.originalResponse.statusCode = code;
+        }
+    }
+    get statusCode() {
+        return this._statusCode;
+    }
+    get headers() {
+        return { ...this._headers };
+    }
+    send() {
+        throw `Lambda response doesn't have "send" method`;
+    }
+    get original() {
+        return this.originalResponse;
     }
 }
-exports.Response = Response;
+exports.LResponse = LResponse;

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

@@ -15,7 +15,7 @@ export declare class HttpServer extends Socket {
     };
     private requestHandler;
     private createRequest;
-    private applyMiddlewares;
+    private beforeRequest;
     private findController;
     private sendResponse;
     private handleError;