quantum-flow 1.3.7 → 1.3.10

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

@@ -1,13 +1,10 @@
-import { APIGatewayProxyEvent, APIGatewayProxyResult, Context, Handler } from 'aws-lambda';
-import { LambdaApp, LambdaRequest, LambdaResponse } from '../../types/index.js';
+import { LambdaApp } from '../../types/index.js';
+import { Handler } from 'aws-lambda';
 export declare class LambdaAdapter {
-    private static getHeaderValue;
-    static toRequest(event: APIGatewayProxyEvent, context: Context): LambdaRequest;
-    static createResponseBody(response: any): any;
-    static toLambdaResponse(response: any, request?: LambdaRequest): LambdaResponse;
-    static createHandler(Contoller: new (...args: any[]) => LambdaApp): Handler<APIGatewayProxyEvent, APIGatewayProxyResult>;
-    private static safeHeaders;
-    private static safeParams;
+    static createHandler(Controller: new (...args: any[]) => LambdaApp): Handler;
+    private static getEventType;
+    private static toRequest;
+    private static toLambdaResponse;
+    private static handleError;
     private static getSourceIp;
-    private static getUserAgent;
 }

package/dist/app/aws/lambda.js

@@ -1,244 +1,219 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LambdaAdapter = void 0;
-const _constants_1 = require("../../constants.js");
 const _utils_1 = require("../../utils/index.js");
 class LambdaAdapter {
-    static getHeaderValue(headers, headerName) {
-        const value = headers?.[headerName] || headers?.[headerName.toLowerCase()];
-        if (!value)
-            return undefined;
-        if (Array.isArray(value)) {
-            return value[0];
+    static createHandler(Controller) {
+        return async (event, context) => {
+            const instance = new Controller();
+            if (Object.hasOwn(instance, 'beforeStart')) {
+                await instance.beforeStart?.();
+            }
+            try {
+                const eventType = this.getEventType(event);
+                const normalizedEvent = (0, _utils_1.normalizeEvent)(event, eventType);
+                const request = this.toRequest(normalizedEvent, context);
+                if (typeof instance.handleRequest !== 'function') {
+                    throw new Error('Controller must have handleRequest method');
+                }
+                const response = await instance.handleRequest(request);
+                return this.toLambdaResponse(response, request, 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 value;
+        return 'rest';
     }
     static toRequest(event, context) {
         const query = {};
-        if (event.queryStringParameters) {
+        if (event.multiValueQueryStringParameters) {
+            Object.entries(event.multiValueQueryStringParameters).forEach(([key, value]) => {
+                query[key] = value;
+            });
+        }
+        else {
             Object.entries(event.queryStringParameters).forEach(([key, value]) => {
-                if (event.multiValueQueryStringParameters?.[key]) {
-                    query[key] = event.multiValueQueryStringParameters[key];
-                }
-                else {
-                    query[key] = value || '';
-                }
+                query[key] = value;
             });
         }
         const cookies = {};
-        const cookieHeader = event.headers?.Cookie || event.headers?.cookie;
+        const cookieHeader = event.headers?.Cookie || event.headers?.cookie || event.headers?.cookies;
         if (cookieHeader) {
-            cookieHeader.split(';').forEach((cookie) => {
-                const [name, value] = cookie.trim().split('=');
-                if (name && value) {
-                    cookies[name] = decodeURIComponent(value);
-                }
-            });
-        }
-        let body = (0, _utils_1.ParseBody)(event);
-        const protocol = event.headers?.['x-forwarded-proto'] || 'http';
-        const host = event.headers?.host || 'localhost';
-        const cleanPath = event.path.split('?')[0];
-        const fullUrl = `${protocol}://${host}${cleanPath.startsWith('/') ? '' : '/'}${cleanPath}`;
-        let url;
-        try {
-            url = new URL(fullUrl);
-            if (event.queryStringParameters) {
-                Object.entries(event.queryStringParameters).forEach(([key, value]) => {
-                    if (value)
-                        url.searchParams.append(key, value);
+            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);
                 });
             }
         }
-        catch (error) {
-            console.error('❌ Failed to create URL:', fullUrl, error);
-            url = new URL('http://localhost/');
+        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,
-            path: cleanPath,
+            method: event.httpMethod.toUpperCase(),
             url,
-            headers: this.safeHeaders(event.headers),
+            headers: event.headers,
             query,
             body,
-            params: this.safeParams(event.pathParameters),
+            params: event.pathParameters,
             cookies,
             event,
             context,
-            isBase64Encoded: event.isBase64Encoded || false,
+            rawBody,
+            path: event.path,
+            isBase64Encoded: event.isBase64Encoded,
             requestId: context.awsRequestId,
             stage: event.requestContext?.stage || '$default',
             sourceIp: this.getSourceIp(event),
-            userAgent: this.getUserAgent(event),
+            _startTime: Date.now(),
+            userAgent: typeof event.headers['user-agent'] === 'string'
+                ? event.headers['user-agent']
+                : event.headers['user-agent']?.[0] || 'unknown',
         };
     }
-    static createResponseBody(response) {
-        let body = response;
-        if (response && typeof response === 'object') {
-            if ('data' in response) {
-                body = {
-                    data: response.data,
-                    timestamp: new Date().toISOString(),
-                };
-            }
-            else if (response.body) {
-                return response;
-            }
-            else {
-                body = {
-                    data: response,
-                    timestamp: new Date().toISOString(),
-                };
-            }
-        }
-        return body;
-    }
-    static toLambdaResponse(response, request) {
-        let statusCode = response.status ?? 200;
-        let body = this.createResponseBody(response);
-        let headers = {
+    static toLambdaResponse(response, request, eventType) {
+        const statusCode = response.status || 200;
+        const headers = {
             'Content-Type': 'application/json',
-            'X-Request-Id': request?.requestId || 'unknown',
-            'X-Powered-By': 'Lambda Decorators',
+            'X-Request-Id': request.requestId,
+            ...(response.headers || {}),
         };
-        const cookies = [];
-        if (response && typeof response === 'object') {
-            if ('data' in response) {
-                body = {
-                    success: _constants_1.OK_STATUSES.includes(statusCode),
-                    data: response.data,
-                    timestamp: new Date().toISOString(),
-                    requestId: request?.requestId,
-                };
-            }
-            else if (response.body) {
-                return response;
+        const originHeader = request.headers['origin'] || request.headers['Origin'];
+        let origin;
+        if (originHeader) {
+            if (Array.isArray(originHeader)) {
+                origin = originHeader[0];
             }
             else {
-                body = {
-                    success: _constants_1.OK_STATUSES.includes(statusCode),
-                    data: response,
-                    timestamp: new Date().toISOString(),
-                    requestId: request?.requestId,
-                };
+                origin = originHeader;
             }
         }
-        let origin = LambdaAdapter.getHeaderValue(request?.headers, 'origin');
-        const originHeader = Array.isArray(origin) ? origin[0] : origin;
-        if (originHeader) {
-            headers['Access-Control-Allow-Origin'] = originHeader;
+        if (origin) {
+            headers['Access-Control-Allow-Origin'] = origin;
             headers['Access-Control-Allow-Credentials'] = 'true';
             headers['Access-Control-Allow-Methods'] = 'GET,POST,PUT,DELETE,OPTIONS';
             headers['Access-Control-Allow-Headers'] =
                 'Content-Type,Authorization,X-Amz-Date,X-Api-Key,X-Amz-Security-Token';
         }
-        if (request?.cookies && Object.keys(request.cookies).length > 0) {
-            Object.entries(request.cookies).forEach(([name, value]) => {
-                cookies.push(`${name}=${encodeURIComponent(value)}; Path=/; HttpOnly`);
-            });
-        }
-        const lambdaResponse = {
+        const body = JSON.stringify({
+            success: statusCode < 400,
+            data: response.data,
+            timestamp: new Date().toISOString(),
+        });
+        const commonResponse = {
             statusCode,
             headers,
-            body: JSON.stringify(body),
-            isBase64Encoded: false,
+            body: response.data,
+            timestamp: new Date().toISOString(),
         };
-        if (cookies.length > 0) {
-            lambdaResponse.cookies = cookies;
-        }
-        if (cookies.length > 0) {
-            lambdaResponse.multiValueHeaders = {
-                'Set-Cookie': cookies,
-            };
-        }
-        return lambdaResponse;
-    }
-    static createHandler(Contoller) {
-        const handler = async (event, context) => {
-            const instance = new Contoller();
-            if (Object.hasOwn(instance, 'beforeStart')) {
-                await instance.beforeStart?.();
-            }
-            try {
-                const request = LambdaAdapter.toRequest(event, context);
-                if (typeof instance.handleRequest === 'function') {
-                    const response = await instance.handleRequest(request);
-                    return LambdaAdapter.toLambdaResponse(response, request);
-                }
-                else {
-                    throw new Error('Controller must have handleRequest method');
-                }
-            }
-            catch (error) {
-                console.error('❌ Lambda error:', error);
-                const errorResponse = {
-                    statusCode: error.status || 500,
-                    headers: {
-                        'Content-Type': 'application/json',
-                        'X-Request-Id': context.awsRequestId,
-                        'Access-Control-Allow-Origin': event.headers?.origin || event.headers?.Origin || '*',
-                        'Access-Control-Allow-Credentials': 'true',
-                    },
-                    body: JSON.stringify({
-                        success: false,
-                        message: error.message || 'Internal Server Error',
-                        requestId: context.awsRequestId,
-                    }),
+        switch (eventType) {
+            case 'rest':
+                return { ...commonResponse, isBase64Encoded: false };
+            case 'http':
+                return {
+                    ...commonResponse,
+                    cookies: request.cookies
+                        ? Object.entries(request.cookies).map(([k, v]) => `${k}=${encodeURIComponent(v)}`)
+                        : undefined,
                 };
-                if (error.cookies) {
-                    errorResponse.cookies = error.cookies;
-                }
-                return errorResponse;
-            }
-        };
-        return handler;
-    }
-    static safeHeaders(headers) {
-        const result = {};
-        if (!headers)
-            return result;
-        Object.entries(headers).forEach(([key, value]) => {
-            if (value !== undefined) {
-                result[key] = value;
-            }
-        });
-        return result;
+            case 'url':
+                return {
+                    ...commonResponse,
+                    cookies: request.cookies
+                        ? Object.entries(request.cookies).map(([k, v]) => `${k}=${encodeURIComponent(v)}`)
+                        : undefined,
+                };
+            default:
+                return {
+                    statusCode,
+                    headers,
+                    body,
+                };
+        }
     }
-    static safeParams(params) {
-        const result = {};
-        if (!params)
-            return result;
-        Object.entries(params).forEach(([key, value]) => {
-            if (value !== undefined) {
-                result[key] = value;
-            }
+    static handleError(error, event, context) {
+        const eventType = this.getEventType(event);
+        const statusCode = error.status || 500;
+        const body = JSON.stringify({
+            success: false,
+            message: error.message || 'Internal Server Error',
+            requestId: context.awsRequestId,
         });
-        return result;
+        const headers = {
+            'Content-Type': 'application/json',
+            'X-Request-Id': context.awsRequestId,
+            'Access-Control-Allow-Origin': '*',
+            'Access-Control-Allow-Credentials': 'true',
+        };
+        switch (eventType) {
+            case 'rest':
+                return {
+                    statusCode,
+                    headers,
+                    body,
+                    isBase64Encoded: false,
+                };
+            default:
+                return {
+                    statusCode,
+                    headers,
+                    body,
+                };
+        }
     }
     static getSourceIp(event) {
-        if (event.requestContext?.identity?.sourceIp) {
-            return event.requestContext.identity.sourceIp;
-        }
-        const forwardedFor = event.headers?.['x-forwarded-for'];
+        const forwardedFor = event.headers['x-forwarded-for'];
         if (forwardedFor) {
-            if (typeof forwardedFor === 'string') {
-                return forwardedFor.split(',')[0].trim();
-            }
-            if (Array.isArray(forwardedFor) && forwardedFor.length > 0) {
+            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';
     }
-    static getUserAgent(event) {
-        const ua = event.headers?.['user-agent'];
-        if (!ua)
-            return 'unknown';
-        if (typeof ua === 'string')
-            return ua;
-        if (Array.isArray(ua) && ua.length > 0)
-            return ua[0];
-        return 'unknown';
-    }
 }
 exports.LambdaAdapter = LambdaAdapter;

package/dist/examples/app.d.ts

@@ -0,0 +1,5 @@
+import 'reflect-metadata';
+export declare class Root {
+}
+export declare class App {
+}

package/dist/examples/app.js

@@ -0,0 +1,34 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.App = exports.Root = void 0;
+const core_1 = require("quantum-flow/core");
+const http_1 = require("quantum-flow/http");
+require("reflect-metadata");
+const user_1 = require("./controllers/user");
+let Root = class Root {
+};
+exports.Root = Root;
+exports.Root = Root = __decorate([
+    (0, core_1.Controller)({ prefix: 'api', controllers: [user_1.User] })
+], Root);
+let App = class App {
+};
+exports.App = App;
+exports.App = App = __decorate([
+    (0, http_1.Server)({
+        controllers: [Root],
+        websocket: { enabled: true },
+        interceptor: (data) => data,
+        errorHandler: (err) => err,
+    }),
+    (0, http_1.Port)(3000),
+    (0, core_1.Use)((data) => data),
+    (0, core_1.Use)((data) => data),
+    (0, core_1.Catch)((err) => err)
+], App);

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

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

package/dist/examples/controllers/userMetadata.js

@@ -27,6 +27,9 @@ let UserMetadata = class UserMetadata {
     async getUserMetadata(params) {
         return params;
     }
+    async createMeta(body, params) {
+        return { body, params };
+    }
 };
 exports.UserMetadata = UserMetadata;
 __decorate([
@@ -36,6 +39,14 @@ __decorate([
     __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", Promise)
 ], UserMetadata.prototype, "getUserMetadata", null);
+__decorate([
+    (0, core_1.POST)('/:meta'),
+    __param(0, (0, core_1.Body)()),
+    __param(1, (0, core_1.Params)(DTO, 'meta')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], UserMetadata.prototype, "createMeta", null);
 exports.UserMetadata = UserMetadata = __decorate([
     (0, core_1.Controller)({ prefix: 'metadata' })
 ], UserMetadata);

package/dist/examples/lambda.d.ts

@@ -0,0 +1 @@
+export declare const handler: import("aws-lambda").Handler;

package/dist/examples/lambda.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handler = void 0;
+const app_1 = require("./app");
+const aws_1 = require("quantum-flow/aws");
+exports.handler = aws_1.LambdaAdapter.createHandler(app_1.Root);

package/dist/examples/mock/context.d.ts

@@ -0,0 +1,14 @@
+export declare const mockContext: {
+    awsRequestId: string;
+    functionName: string;
+    functionVersion: string;
+    invokedFunctionArn: string;
+    memoryLimitInMB: string;
+    logGroupName: string;
+    logStreamName: string;
+    getRemainingTimeInMillis: () => number;
+    callbackWaitsForEmptyEventLoop: boolean;
+    done: () => void;
+    fail: () => void;
+    succeed: () => void;
+};

package/dist/examples/mock/context.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mockContext = void 0;
+exports.mockContext = {
+    awsRequestId: 'local-req-id-123456',
+    functionName: 'localFunction',
+    functionVersion: '$LATEST',
+    invokedFunctionArn: 'arn:aws:lambda:local:123456789012:function:localFunction',
+    memoryLimitInMB: '128',
+    logGroupName: '/aws/lambda/localFunction',
+    logStreamName: '2023/01/01/[$LATEST]abcdefghijk',
+    getRemainingTimeInMillis: () => 30000,
+    callbackWaitsForEmptyEventLoop: true,
+    done: () => { },
+    fail: () => { },
+    succeed: () => { },
+};

package/dist/examples/server.d.ts

@@ -1 +1 @@
-import 'reflect-metadata';
+export {};

package/dist/examples/server.js

@@ -1,37 +1,6 @@
 "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;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const core_1 = require("quantum-flow/core");
 const http_1 = require("quantum-flow/http");
-require("reflect-metadata");
-const user_1 = require("./controllers/user");
-let Root = class Root {
-};
-Root = __decorate([
-    (0, core_1.Controller)({ prefix: 'api', controllers: [user_1.User] })
-], Root);
-let App = 
-// @Catch((error) => ({ status: 400, error }))
-class App {
-};
-App = __decorate([
-    (0, http_1.Server)({
-        controllers: [Root],
-        websocket: { enabled: true },
-        interceptor: (data) => data,
-        errorHandler: (err) => {
-            return err;
-        },
-    }),
-    (0, http_1.Port)(3000),
-    (0, core_1.Use)((data) => data),
-    (0, core_1.Use)((data) => data)
-    // @Catch((error) => ({ status: 400, error }))
-], App);
-const server = new http_1.HttpServer(App);
+const app_1 = require("./app");
+const server = new http_1.HttpServer(app_1.App);
 server.listen().catch(console.error);

package/dist/types/common.d.ts

@@ -12,6 +12,7 @@ export interface HttpError extends Error {
 export type AppRequest<B = unknown, Q extends P_Q = unknown, P extends P_Q = unknown> = {
     method: HTTP_METHODS;
     url: URL;
+    path?: string;
     headers: IncomingHttpHeaders;
     query?: Q;
     params?: P;
@@ -20,6 +21,12 @@ export type AppRequest<B = unknown, Q extends P_Q = unknown, P extends P_Q = unk
     isBase64Encoded?: boolean;
     cookies: Record<string, string>;
     _startTime: number;
+    event?: any;
+    context?: any;
+    requestId?: string;
+    stage?: string;
+    sourceIp?: string;
+    userAgent?: string;
 };
 export type Router = (req: AppRequest, res?: ServerResponse) => Promise<{
     status: number;

package/dist/types/lambda.d.ts

@@ -1,4 +1,44 @@
-import { APIGatewayProxyEvent, Context } from 'aws-lambda';
+import { APIGatewayProxyEvent, APIGatewayProxyEventV2, Context } from 'aws-lambda';
+export interface LambdaFunctionUrlEvent {
+    version: string;
+    routeKey: string;
+    rawPath: string;
+    rawQueryString: string;
+    headers: Record<string, string>;
+    body?: string;
+    isBase64Encoded?: boolean;
+    requestContext: {
+        accountId: string;
+        apiId: string;
+        domainName: string;
+        domainPrefix: string;
+        http: {
+            method: string;
+            path: string;
+            protocol: string;
+            sourceIp: string;
+            userAgent: string;
+        };
+        requestId: string;
+        routeKey: string;
+        stage: string;
+        time: string;
+        timeEpoch: number;
+    };
+}
+export type LambdaEvent = APIGatewayProxyEvent | APIGatewayProxyEventV2 | LambdaFunctionUrlEvent;
+export interface NormalizedEvent {
+    httpMethod: string;
+    path: string;
+    headers: Record<string, string | string[]>;
+    queryStringParameters: Record<string, string>;
+    multiValueQueryStringParameters?: Record<string, string[]>;
+    pathParameters: Record<string, string>;
+    body: string | null;
+    isBase64Encoded: boolean;
+    cookies?: string[];
+    requestContext: any;
+}
 export interface LambdaRequest {
     method: string;
     path: string;
@@ -14,7 +54,8 @@ export interface LambdaRequest {
     sourceIp: string;
     userAgent: string;
     url: URL;
-    event: APIGatewayProxyEvent;
+    event: NormalizedEvent;
+    _startTime: number;
 }
 export interface LambdaResponse {
     statusCode: number;

package/dist/utils/index.d.ts

@@ -1,8 +1,9 @@
 export * from './controller';
+export * from './endpoint';
 export * from './helper';
+export * from './lambda';
 export * from './multipart';
 export * from './parsers';
 export * from './server';
 export * from './transform';
 export * from './validate';
-export * from './endpoint';

package/dist/utils/index.js

@@ -15,10 +15,11 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./controller"), exports);
+__exportStar(require("./endpoint"), exports);
 __exportStar(require("./helper"), exports);
+__exportStar(require("./lambda"), exports);
 __exportStar(require("./multipart"), exports);
 __exportStar(require("./parsers"), exports);
 __exportStar(require("./server"), exports);
 __exportStar(require("./transform"), exports);
 __exportStar(require("./validate"), exports);
-__exportStar(require("./endpoint"), exports);

package/dist/utils/lambda.d.ts

@@ -0,0 +1,2 @@
+import { NormalizedEvent } from '../types/index.js';
+export declare const normalizeEvent: (event: any, type: string) => NormalizedEvent;

package/dist/utils/lambda.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeEvent = void 0;
+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/utils/server.js

@@ -13,7 +13,7 @@ const resolveConfig = (configOrClass) => {
             port: 3000,
             host: 'localhost',
             ...decoratorConfig,
-            errorHandler,
+            errorHandler: decoratorConfig.errorHandler ?? errorHandler,
             interceptors,
             controllers: [...controllers, ...(decoratorConfig.controllers || [])],
         };

package/package.json

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