quantum-flow 1.0.1

package/dist/utils/multipart.js

@@ -0,0 +1,109 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultipartProcessor = void 0;
+// utils/MultipartProcessor.ts
+const multipart = __importStar(require("parse-multipart-data"));
+class MultipartProcessor {
+    static parse(request) {
+        const { body, headers, isBase64Encoded } = request;
+        if (!body) {
+            return { fields: {}, files: {} };
+        }
+        let contentType = headers['content-type'] ?? headers['Content-Type'] ?? '';
+        if (Array.isArray(contentType)) {
+            contentType = contentType[0];
+        }
+        if (!contentType.startsWith('multipart/form-data')) {
+            throw new Error('Not a multipart request');
+        }
+        const boundaryMatch = multipart.getBoundary(contentType);
+        if (!boundaryMatch) {
+            throw new Error('Invalid multipart boundary');
+        }
+        let bodyBuffer;
+        if (Buffer.isBuffer(body)) {
+            bodyBuffer = body;
+        }
+        else if (typeof body === 'string') {
+            bodyBuffer = isBase64Encoded ? Buffer.from(body, 'base64') : Buffer.from(body, 'binary');
+        }
+        else {
+            bodyBuffer = Buffer.from(JSON.stringify(body));
+        }
+        const parts = multipart.parse(bodyBuffer, boundaryMatch);
+        const fields = {};
+        const files = {};
+        parts.forEach((part) => {
+            if (part.filename) {
+                const fieldName = part.name || 'file';
+                const fileData = {
+                    fieldname: fieldName,
+                    filename: part.filename,
+                    contentType: part.type,
+                    data: part.data,
+                    size: part.data.length,
+                    encoding: part.encoding,
+                };
+                if (files[fieldName]) {
+                    if (Array.isArray(files[fieldName])) {
+                        files[fieldName].push(fileData);
+                    }
+                    else {
+                        files[fieldName] = [files[fieldName], fileData];
+                    }
+                }
+                else {
+                    files[fieldName] = fileData;
+                }
+            }
+            else if (part.name) {
+                const text = part.data.toString('utf-8').trim();
+                try {
+                    fields[part.name] = JSON.parse(text);
+                }
+                catch {
+                    fields[part.name] = text;
+                }
+            }
+        });
+        return { fields, files };
+    }
+    static isMultipart(request) {
+        const contentType = request.headers?.['content-type'] || request.headers?.['Content-Type'] || '';
+        return contentType.startsWith('multipart/form-data');
+    }
+}
+exports.MultipartProcessor = MultipartProcessor;

package/dist/utils/parsers.d.ts

@@ -0,0 +1,4 @@
+import http from 'http';
+export declare const ParseQuery: (url: URL) => Record<string, string | string[]>;
+export declare const ParseBody: (request: any) => any;
+export declare const ParseCookies: (req: http.IncomingMessage) => Record<string, string>;

package/dist/utils/parsers.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParseCookies = exports.ParseBody = exports.ParseQuery = void 0;
+const ParseQuery = (url) => {
+    const params = url.searchParams;
+    const query = {};
+    for (const key of params.keys()) {
+        const values = params.getAll(key);
+        query[key] = values.length > 1 ? values : values[0];
+    }
+    return query;
+};
+exports.ParseQuery = ParseQuery;
+const ParseBody = (request) => {
+    if (request.body && typeof request.body === 'object' && !Buffer.isBuffer(request.body)) {
+        return request.body;
+    }
+    const { body, headers, isBase64Encoded } = request;
+    if (!body) {
+        return {};
+    }
+    let contentType = headers['content-type'] ?? headers['Content-Type'] ?? '';
+    if (Array.isArray(contentType)) {
+        contentType = contentType[0];
+    }
+    const cleanContentType = contentType.split(';')[0].trim().toLowerCase();
+    if (cleanContentType === 'application/json') {
+        try {
+            if (typeof body === 'string') {
+                return JSON.parse(body);
+            }
+            if (Buffer.isBuffer(body)) {
+                return JSON.parse(body.toString('utf8'));
+            }
+        }
+        catch (error) {
+            console.error(error);
+            throw error;
+        }
+    }
+    if (cleanContentType.startsWith('text/')) {
+        if (Buffer.isBuffer(body)) {
+            return { text: body.toString('utf8') };
+        }
+        return { text: body };
+    }
+    if (cleanContentType === 'application/x-www-form-urlencoded') {
+        if (Buffer.isBuffer(body)) {
+            const text = body.toString('utf8');
+            const params = new URLSearchParams(text);
+            const result = {};
+            params.forEach((value, key) => {
+                result[key] = value;
+            });
+            return result;
+        }
+    }
+    if (Buffer.isBuffer(body)) {
+        return { raw: body.toString('utf8') };
+    }
+    return body;
+};
+exports.ParseBody = ParseBody;
+const ParseCookies = (req) => {
+    const cookieHeader = req.headers.cookie;
+    if (!cookieHeader)
+        return {};
+    return cookieHeader.split(';').reduce((cookies, cookie) => {
+        const [name, value] = cookie.trim().split('=');
+        if (name && value) {
+            cookies[name] = decodeURIComponent(value);
+        }
+        return cookies;
+    }, {});
+};
+exports.ParseCookies = ParseCookies;

package/dist/utils/server.d.ts

@@ -0,0 +1,4 @@
+import { ServerConfig } from '@types';
+import http from 'http';
+export declare const resolveConfig: (configOrClass?: any) => ServerConfig;
+export declare const collectRawBody: (req: http.IncomingMessage) => Promise<Buffer>;

package/dist/utils/server.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectRawBody = exports.resolveConfig = void 0;
+const _constants_1 = require("@constants");
+const resolveConfig = (configOrClass) => {
+    let config = {};
+    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) || [];
+        config = {
+            port: 3000,
+            host: 'localhost',
+            ...decoratorConfig,
+            controllers: [...controllers, ...(decoratorConfig.controllers || [])],
+        };
+    }
+    else if (configOrClass && typeof configOrClass === 'object') {
+        config = { port: 3000, host: 'localhost', ...configOrClass };
+    }
+    else {
+        config = {
+            port: 3000,
+            host: 'localhost',
+            controllers: [],
+        };
+        console.log('⚙️ Using default configuration');
+    }
+    return config;
+};
+exports.resolveConfig = resolveConfig;
+const collectRawBody = (req) => {
+    return new Promise((resolve) => {
+        const chunks = [];
+        req.on('data', (chunk) => {
+            chunks.push(Buffer.from(chunk));
+        });
+        req.on('end', () => {
+            const buffer = Buffer.concat(chunks);
+            resolve(buffer);
+        });
+        req.on('error', () => {
+            resolve(Buffer.from(''));
+        });
+    });
+};
+exports.collectRawBody = collectRawBody;

package/dist/utils/transform.d.ts

@@ -0,0 +1 @@
+export declare function transformAndValidate(dtoClass: any, data: any): Promise<any>;

package/dist/utils/transform.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformAndValidate = transformAndValidate;
+async function transformAndValidate(dtoClass, data) {
+    if (!dtoClass)
+        return data;
+    if (typeof dtoClass.from === 'function') {
+        return dtoClass.from(data);
+    }
+    if (typeof dtoClass === 'function') {
+        const instance = new dtoClass();
+        Object.entries(data).forEach(([key, val]) => {
+            instance[key] = val;
+        });
+        Object.assign(instance, data);
+        if (typeof instance.validate === 'function') {
+            await instance.validate();
+        }
+        console.log('ppppppp', dtoClass, data);
+        return instance;
+    }
+    return data;
+}

package/dist/utils/validate.d.ts

@@ -0,0 +1 @@
+export declare function validate(dtoClass: any, data: any): Promise<any>;

package/dist/utils/validate.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validate = validate;
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+async function validate(dtoClass, data) {
+    if (!dtoClass) {
+        return data;
+    }
+    try {
+        if (typeof dtoClass.from === 'function') {
+            return dtoClass.from(data);
+        }
+        if (typeof dtoClass === 'function') {
+            const instance = (0, class_transformer_1.plainToInstance)(dtoClass, data);
+            const errors = await (0, class_validator_1.validate)(instance);
+            if (errors.length > 0) {
+                const formattedErrors = formatValidationErrors(errors);
+                throw {
+                    status: 400,
+                    message: 'Validation failed',
+                    errors: formattedErrors,
+                };
+            }
+            return instance;
+        }
+        return data;
+    }
+    catch (error) {
+        throw error;
+    }
+}
+function formatValidationErrors(errors) {
+    return errors.map((error) => {
+        const constraints = error.constraints || {};
+        const children = error.children && error.children.length > 0
+            ? formatValidationErrors(error.children)
+            : undefined;
+        return {
+            property: error.property,
+            value: error.value,
+            constraints: Object.values(constraints),
+            children,
+        };
+    });
+}

package/dist/validators/Validate.d.ts

@@ -0,0 +1,3 @@
+type ToValidate = 'query' | 'body' | 'params' | 'headers';
+export declare function Validate(param: ToValidate, dtoClass: any): (target: any, propertyKey?: string, descriptor?: PropertyDescriptor) => void;
+export {};

package/dist/validators/Validate.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Validate = Validate;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const class_validator_1 = require("class-validator");
+function Validate(param, dtoClass) {
+    return function (target, propertyKey, descriptor) {
+        // METHOD DECORATOR
+        if (descriptor) {
+            wrapMethod(descriptor, param, dtoClass);
+            return;
+        }
+        // CLASS DECORATOR
+        const prototype = target.prototype;
+        Object.getOwnPropertyNames(prototype).forEach((method) => {
+            if (method === 'constructor')
+                return;
+            const desc = Object.getOwnPropertyDescriptor(prototype, method);
+            if (!desc || typeof desc.value !== 'function')
+                return;
+            wrapMethod(desc, param, dtoClass);
+            Object.defineProperty(prototype, method, desc);
+        });
+    };
+}
+function wrapMethod(descriptor, param, dtoClass) {
+    const originalMethod = descriptor.value;
+    descriptor.value = async function (...args) {
+        const value = args[0][param];
+        const instance = new dtoClass();
+        Object.entries(value || {}).forEach(([key, val]) => {
+            instance[key] = val;
+        });
+        const errors = await (0, class_validator_1.validate)(instance, { whitelist: true });
+        if (errors.length) {
+            throw { status: 422, message: 'Validation failed', data: errors };
+        }
+        return originalMethod.apply(this, args);
+    };
+}

package/dist/validators/index.d.ts

@@ -0,0 +1 @@
+export * from './Validate';

package/dist/validators/index.js

@@ -0,0 +1,17 @@
+"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("./Validate"), exports);

package/eslint.config.mjs

@@ -0,0 +1,84 @@
+import pluginJs from '@eslint/js';
+import prettierConfig from 'eslint-config-prettier';
+import importPlugin from 'eslint-plugin-import';
+import prettierPlugin from 'eslint-plugin-prettier';
+import simpleImportSort from 'eslint-plugin-simple-import-sort';
+import unusedImports from 'eslint-plugin-unused-imports';
+import tseslint from 'typescript-eslint';
+
+export default tseslint.defineConfig(
+  {
+    ignores: [
+      'dist/**',
+      'node_modules/**',
+      'bin/**',
+      'build/**',
+      '.config/*',
+      'cdk.out/**',
+      'yarn.lock',
+    ],
+  },
+
+  pluginJs.configs.recommended,
+  ...tseslint.configs.recommended,
+
+  {
+    files: ['**/*.{ts,js,mts,mjs}'],
+    plugins: {
+      prettier: prettierPlugin,
+      'unused-imports': unusedImports,
+      import: importPlugin,
+      'simple-import-sort': simpleImportSort,
+    },
+    languageOptions: {
+      parserOptions: {
+        project: true,
+      },
+    },
+    rules: {
+      'prettier/prettier': [
+        'error',
+        {
+          singleQuote: true,
+          trailingComma: 'all',
+          printWidth: 100,
+          tabWidth: 2,
+          unusedImports: 'all',
+        },
+      ],
+
+      'unused-imports/no-unused-imports': 'warn',
+      'unused-imports/no-unused-vars': 'off',
+      'simple-import-sort/imports': 'error',
+      'simple-import-sort/exports': 'error',
+      'import/first': 'error',
+      'import/no-duplicates': 'error',
+
+      '@typescript-eslint/no-explicit-any': ['error', { ignoreRestArgs: true }],
+      '@typescript-eslint/no-unused-vars': [
+        'error',
+        {
+          argsIgnorePattern: '^_',
+          varsIgnorePattern: '^_',
+          caughtErrorsIgnorePattern: '^_',
+        },
+      ],
+
+      'lines-between-class-members': [
+        'error',
+        {
+          enforce: [
+            { blankLine: 'always', prev: '*', next: 'method' },
+            { blankLine: 'never', prev: 'field', next: 'field' },
+          ],
+        },
+      ],
+
+      'max-len': 'off',
+      'no-duplicate-imports': 'off',
+      'brace-style': ['error', '1tbs', { allowSingleLine: true }],
+    },
+  },
+
+  prettierConfig,
+);

package/nodemon.json

@@ -0,0 +1,5 @@
+{
+  "watch": ["src", "./server.ts", "./testing"],
+  "ext": "ts,tsx",
+  "exec": "ts-node --files -r tsconfig-paths/register ./testing/server.ts"
+}

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "quantum-flow",
+  "version": "1.0.1",
+  "description": "Decorator-based API framework",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "dev": "nodemon --config ./nodemon.json",
+    "prepublishOnly": "yarn build"
+  },
+  "exports": {
+    "./core": {
+      "import": "./dist/core/index.js",
+      "require": "./dist/core/index.js",
+      "types": "./dist/core/index.d.ts"
+    },
+    "./http": {
+      "import": "./dist/app/http/index.js",
+      "require": "./dist/app/http/index.js",
+      "types": "./dist/app/http/index.d.ts"
+    },
+    "./aws": {
+      "import": "./dist/app/aws/index.js",
+      "require": "./dist/app/aws/index.js",
+      "types": "./dist/app/aws/index.d.ts"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yourusername/your-repo.git"
+  },
+  "keywords": [
+    "api",
+    "decorators",
+    "http",
+    "websocket",
+    "typescript",
+    "aws",
+    "rest"
+  ],
+  "author": "Naumov Oleh",
+  "dependencies": {
+    "aws-lambda": "^1.0.7",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.15.1",
+    "parse-multipart-data": "^1.5.0",
+    "reflect-metadata": "^0.2.2",
+    "tsconfig-paths": "^4.2.0",
+    "uuid": "^13.0.0",
+    "ws": "^8.19.0"
+  },
+  "peerDependencies": {
+    "typescript": ">=4.0.0",
+    "ts-node": ">=10.9.2"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@types/aws-lambda": "^8.10.161",
+    "@types/node": "^25.3.5",
+    "@types/ws": "^8.18.1",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-prettier": "^5.5.5",
+    "eslint-plugin-simple-import-sort": "^12.1.1",
+    "eslint-plugin-unused-imports": "^4.4.1",
+    "nodemon": "^3.1.14",
+    "typescript-eslint": "^8.56.1"
+  }
+}

package/src/app/aws/index.ts

@@ -0,0 +1 @@
+export * from './lambda';