quantum-flow 1.3.9 → 1.4.0

package/dist/utils/cors.d.ts

@@ -0,0 +1,8 @@
+import { CORSConfig } from '../types/index.js';
+export declare function handleCORS(req: any, res: any, config: CORSConfig): {
+    permitted: boolean;
+    continue: boolean;
+};
+export declare function isPreflightRequest(req: any): boolean;
+export declare const getCORSConfig: (controller: any, methodName?: string) => CORSConfig | null;
+export declare const getCORSHeaders: (req: any, config: CORSConfig) => Record<string, string>;

package/dist/utils/cors.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCORSHeaders = exports.getCORSConfig = void 0;
+exports.handleCORS = handleCORS;
+exports.isPreflightRequest = isPreflightRequest;
+const _constants_1 = require("../constants.js");
+function handleCORS(req, res, config) {
+    const origin = req.headers.origin || req.headers.Origin || req.url.origin;
+    function isOriginAllowed() {
+        if (!origin)
+            return false;
+        if (config.origin === '*')
+            return true;
+        if (typeof config.origin === 'string')
+            return config.origin === origin;
+        if (Array.isArray(config.origin))
+            return config.origin.includes(origin);
+        if (typeof config.origin === 'function')
+            return config.origin(origin);
+        return false;
+    }
+    if (origin && !isOriginAllowed()) {
+        res.statusCode = 403;
+        res.setHeader('Content-Type', 'application/json');
+        return { permitted: false, continue: false };
+    }
+    if (req.method === 'OPTIONS') {
+        if (origin) {
+            res.setHeader('Access-Control-Allow-Origin', origin);
+        }
+        else if (config.origin === '*') {
+            res.setHeader('Access-Control-Allow-Origin', '*');
+        }
+        if (config.methods) {
+            res.setHeader('Access-Control-Allow-Methods', config.methods.join(', '));
+        }
+        if (config.allowedHeaders) {
+            res.setHeader('Access-Control-Allow-Headers', config.allowedHeaders.join(', '));
+        }
+        if (config.credentials) {
+            res.setHeader('Access-Control-Allow-Credentials', 'true');
+        }
+        if (config.maxAge) {
+            res.setHeader('Access-Control-Max-Age', config.maxAge.toString());
+        }
+        res.statusCode = config.optionsSuccessStatus || 204;
+        return { permitted: true, continue: false };
+    }
+    if (origin) {
+        res.setHeader('Access-Control-Allow-Origin', origin);
+        if (config.credentials) {
+            res.setHeader('Access-Control-Allow-Credentials', 'true');
+        }
+        if (config.exposedHeaders) {
+            res.setHeader('Access-Control-Expose-Headers', config.exposedHeaders.join(', '));
+        }
+    }
+    return { permitted: true, continue: true };
+}
+function isPreflightRequest(req) {
+    return (req.method === 'OPTIONS' && req.headers['access-control-request-method'] && req.headers.origin);
+}
+const getCORSConfig = (controller, methodName) => {
+    if (methodName) {
+        const methodConfig = Reflect.getMetadata(_constants_1.CORS_METADATA, controller, methodName);
+        if (methodConfig) {
+            return methodConfig;
+        }
+    }
+    if (controller && controller.constructor) {
+        const classConfig = Reflect.getMetadata(_constants_1.CORS_METADATA, controller.constructor.prototype);
+        if (classConfig) {
+            return classConfig;
+        }
+    }
+    return null;
+};
+exports.getCORSConfig = getCORSConfig;
+const getCORSHeaders = (req, config) => {
+    const headers = {};
+    const origin = req?.headers?.origin || req?.headers?.Origin;
+    if (!origin)
+        return headers;
+    let allowedOrigin = null;
+    if (config.origin === '*') {
+        allowedOrigin = '*';
+    }
+    else if (typeof config.origin === 'string') {
+        allowedOrigin = config.origin;
+    }
+    else if (Array.isArray(config.origin)) {
+        if (config.origin.includes(origin)) {
+            allowedOrigin = origin;
+        }
+    }
+    else if (typeof config.origin === 'function') {
+        if (config.origin(origin)) {
+            allowedOrigin = origin;
+        }
+    }
+    else if (config.origin === true) {
+        allowedOrigin = origin;
+    }
+    if (allowedOrigin) {
+        headers['Access-Control-Allow-Origin'] = allowedOrigin;
+        if (config.credentials) {
+            headers['Access-Control-Allow-Credentials'] = 'true';
+        }
+        if (config.exposedHeaders?.length) {
+            headers['Access-Control-Expose-Headers'] = config.exposedHeaders.join(', ');
+        }
+        if (req.method === 'OPTIONS') {
+            if (config.methods?.length) {
+                headers['Access-Control-Allow-Methods'] = config.methods.join(', ');
+            }
+            if (config.allowedHeaders?.length) {
+                headers['Access-Control-Allow-Headers'] = config.allowedHeaders.join(', ');
+            }
+            if (config.maxAge) {
+                headers['Access-Control-Max-Age'] = config.maxAge.toString();
+            }
+        }
+    }
+    return headers;
+};
+exports.getCORSHeaders = getCORSHeaders;

package/dist/utils/index.d.ts

@@ -1,8 +1,10 @@
 export * from './controller';
+export * from './cors';
+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,12 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./controller"), exports);
+__exportStar(require("./cors"), 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/multipart.d.ts

@@ -12,4 +12,5 @@ export declare class MultipartProcessor {
         files: Record<string, MultipartFile | MultipartFile[]>;
     };
     static isMultipart(request: any): boolean;
+    private static getContentType;
 }

package/dist/utils/multipart.js

@@ -69,10 +69,11 @@ class MultipartProcessor {
         parts.forEach((part) => {
             if (part.filename) {
                 const fieldName = part.name || 'file';
+                const contentType = this.getContentType(part);
                 const fileData = {
                     fieldname: fieldName,
                     filename: part.filename,
-                    contentType: part.type,
+                    contentType: contentType ?? part.type,
                     data: part.data,
                     size: part.data.length,
                     encoding: part.encoding,
@@ -105,5 +106,101 @@ class MultipartProcessor {
         const contentType = request.headers?.['content-type'] || request.headers?.['Content-Type'] || '';
         return contentType.startsWith('multipart/form-data');
     }
+    static getContentType(part) {
+        const filename = part.filename || '';
+        const extension = filename.split('.').pop()?.toLowerCase() ?? '';
+        const mimeMap = {
+            txt: 'text/plain',
+            text: 'text/plain',
+            log: 'text/plain',
+            md: 'text/markdown',
+            csv: 'text/csv',
+            ts: 'application/typescript',
+            tsx: 'application/typescript',
+            js: 'application/javascript',
+            jsx: 'application/javascript',
+            mjs: 'application/javascript',
+            cjs: 'application/javascript',
+            json: 'application/json',
+            xml: 'application/xml',
+            yaml: 'application/yaml',
+            yml: 'application/yaml',
+            toml: 'application/toml',
+            php: 'application/x-httpd-php',
+            py: 'text/x-python',
+            rb: 'text/x-ruby',
+            java: 'text/x-java',
+            c: 'text/x-c',
+            cpp: 'text/x-c++',
+            h: 'text/x-c',
+            hpp: 'text/x-c++',
+            go: 'text/x-go',
+            rs: 'text/x-rust',
+            swift: 'text/x-swift',
+            kt: 'text/x-kotlin',
+            kts: 'text/x-kotlin',
+            html: 'text/html',
+            htm: 'text/html',
+            css: 'text/css',
+            scss: 'text/x-scss',
+            sass: 'text/x-sass',
+            less: 'text/x-less',
+            jpg: 'image/jpeg',
+            jpeg: 'image/jpeg',
+            png: 'image/png',
+            gif: 'image/gif',
+            webp: 'image/webp',
+            svg: 'image/svg+xml',
+            ico: 'image/x-icon',
+            bmp: 'image/bmp',
+            tiff: 'image/tiff',
+            tif: 'image/tiff',
+            avif: 'image/avif',
+            heic: 'image/heic',
+            heif: 'image/heif',
+            pdf: 'application/pdf',
+            doc: 'application/msword',
+            docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+            xls: 'application/vnd.ms-excel',
+            xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+            ppt: 'application/vnd.ms-powerpoint',
+            pptx: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+            odt: 'application/vnd.oasis.opendocument.text',
+            ods: 'application/vnd.oasis.opendocument.spreadsheet',
+            odp: 'application/vnd.oasis.opendocument.presentation',
+            zip: 'application/zip',
+            rar: 'application/vnd.rar',
+            '7z': 'application/x-7z-compressed',
+            tar: 'application/x-tar',
+            gz: 'application/gzip',
+            bz2: 'application/x-bzip2',
+            mp3: 'audio/mpeg',
+            wav: 'audio/wav',
+            ogg: 'audio/ogg',
+            m4a: 'audio/mp4',
+            flac: 'audio/flac',
+            aac: 'audio/aac',
+            mp4: 'video/mp4',
+            mpg: 'video/mpeg',
+            mpeg: 'video/mpeg',
+            mov: 'video/quicktime',
+            avi: 'video/x-msvideo',
+            wmv: 'video/x-ms-wmv',
+            flv: 'video/x-flv',
+            webm: 'video/webm',
+            mkv: 'video/x-matroska',
+            m4v: 'video/x-m4v',
+            bin: 'application/octet-stream',
+            exe: 'application/vnd.microsoft.portable-executable',
+            dll: 'application/vnd.microsoft.portable-executable',
+            deb: 'application/vnd.debian.binary-package',
+            rpm: 'application/x-rpm',
+            iso: 'application/x-iso9660-image',
+            sh: 'application/x-sh',
+            bat: 'application/x-msdos-program',
+            ps1: 'application/x-powershell',
+        };
+        return mimeMap[extension];
+    }
 }
 exports.MultipartProcessor = MultipartProcessor;

package/dist/utils/server.js

@@ -15,6 +15,7 @@ const resolveConfig = (configOrClass) => {
             ...decoratorConfig,
             errorHandler: decoratorConfig.errorHandler ?? errorHandler,
             interceptors,
+            cors: decoratorConfig.cors,
             controllers: [...controllers, ...(decoratorConfig.controllers || [])],
         };
     }

package/package.json

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