quantum-flow 1.0.1

package/.prettierrc.json

@@ -0,0 +1,9 @@
+{
+  "trailingComma": "all",
+  "useTabs": false,
+  "tabWidth": 2,
+  "semi": true,
+  "singleQuote": true,
+  "printWidth": 100,
+  "bracketSpacing": true
+}

package/README.md

@@ -0,0 +1,37 @@
+# Your Package Name
+
+Description of your package.
+
+## Installation
+
+```bash
+npm install your-package-name
+```
+
+## Usage
+
+```typescript
+import { greet } from 'your-package-name';
+
+console.log(greet('World'));
+```
+
+## Build
+
+To build the package, run:
+
+```bash
+npm run build
+```
+
+## Test
+
+To run tests, run:
+
+```bash
+npm run test
+```
+
+## License
+
+MIT

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

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

package/dist/app/aws/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("./lambda"), exports);

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

@@ -0,0 +1,13 @@
+import { APIGatewayProxyEvent, APIGatewayProxyResult, Context, Handler } from 'aws-lambda';
+import { LambdaRequest, LambdaResponse } from '@types';
+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: any): Handler<APIGatewayProxyEvent, APIGatewayProxyResult>;
+    private static safeHeaders;
+    private static safeParams;
+    private static getSourceIp;
+    private static getUserAgent;
+}

package/dist/app/aws/lambda.js

@@ -0,0 +1,241 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LambdaAdapter = void 0;
+const _constants_1 = require("@constants");
+const _utils_1 = require("@utils");
+class LambdaAdapter {
+    static getHeaderValue(headers, headerName) {
+        const value = headers?.[headerName] || headers?.[headerName.toLowerCase()];
+        if (!value)
+            return undefined;
+        if (Array.isArray(value)) {
+            return value[0];
+        }
+        return value;
+    }
+    static toRequest(event, context) {
+        const query = {};
+        if (event.queryStringParameters) {
+            Object.entries(event.queryStringParameters).forEach(([key, value]) => {
+                if (event.multiValueQueryStringParameters?.[key]) {
+                    query[key] = event.multiValueQueryStringParameters[key];
+                }
+                else {
+                    query[key] = value || '';
+                }
+            });
+        }
+        const cookies = {};
+        const cookieHeader = event.headers?.Cookie || event.headers?.cookie;
+        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);
+                });
+            }
+        }
+        catch (error) {
+            console.error('❌ Failed to create URL:', fullUrl, error);
+            url = new URL('http://localhost/');
+        }
+        return {
+            method: event.httpMethod,
+            path: cleanPath,
+            url,
+            headers: this.safeHeaders(event.headers),
+            query,
+            body,
+            params: this.safeParams(event.pathParameters),
+            cookies,
+            raw: event,
+            context,
+            isBase64Encoded: event.isBase64Encoded || false,
+            requestId: context.awsRequestId,
+            stage: event.requestContext?.stage || '$default',
+            sourceIp: this.getSourceIp(event),
+            userAgent: this.getUserAgent(event),
+        };
+    }
+    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 = {
+            'Content-Type': 'application/json',
+            'X-Request-Id': request?.requestId || 'unknown',
+            'X-Powered-By': 'Lambda Decorators',
+        };
+        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;
+            }
+            else {
+                body = {
+                    success: _constants_1.OK_STATUSES.includes(statusCode),
+                    data: response,
+                    timestamp: new Date().toISOString(),
+                    requestId: request?.requestId,
+                };
+            }
+        }
+        let originHeader = LambdaAdapter.getHeaderValue(request?.headers, 'origin');
+        if (originHeader) {
+            if (Array.isArray(originHeader)) {
+                origin = originHeader[0];
+            }
+            else {
+                origin = originHeader;
+            }
+        }
+        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 = {
+            statusCode,
+            headers,
+            body: JSON.stringify(body),
+            isBase64Encoded: false,
+        };
+        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();
+            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,
+                    }),
+                };
+                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;
+    }
+    static safeParams(params) {
+        const result = {};
+        if (!params)
+            return result;
+        Object.entries(params).forEach(([key, value]) => {
+            if (value !== undefined) {
+                result[key] = value;
+            }
+        });
+        return result;
+    }
+    static getSourceIp(event) {
+        if (event.requestContext?.identity?.sourceIp) {
+            return event.requestContext.identity.sourceIp;
+        }
+        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) {
+                return forwardedFor[0].split(',')[0].trim();
+            }
+        }
+        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/app/http/Application.d.ts

@@ -0,0 +1,23 @@
+import { ServerConfig } from '@types';
+import http from 'http';
+import { Socket } from './Socket';
+export declare class HttpServer extends Socket {
+    private app;
+    private config;
+    private isRunning;
+    constructor(configOrClass: new (...args: any[]) => any);
+    private logConfig;
+    listen(port?: number, host?: string): Promise<http.Server>;
+    close(): Promise<void>;
+    status(): {
+        running: boolean;
+        config: ServerConfig;
+    };
+    private requestHandler;
+    private createRequest;
+    private applyMiddlewares;
+    private findController;
+    private applyInterceptors;
+    private sendResponse;
+    private handleError;
+}

package/dist/app/http/Application.js

@@ -0,0 +1,208 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpServer = void 0;
+const _constants_1 = require("@constants");
+const _utils_1 = require("@utils");
+const http_1 = __importDefault(require("http"));
+const Socket_1 = require("./Socket");
+const WebsocetService_1 = require("./websocket/WebsocetService");
+const WebsocketServer_1 = require("./websocket/WebsocketServer");
+class HttpServer extends Socket_1.Socket {
+    app;
+    config;
+    isRunning = false;
+    constructor(configOrClass) {
+        super();
+        this.config = (0, _utils_1.resolveConfig)(configOrClass);
+        const app = http_1.default.createServer(this.requestHandler.bind(this));
+        if (this.config.websocket?.enabled) {
+            this.wss = new WebsocketServer_1.WebSocketServer(app, {
+                path: this.config.websocket.path || '/',
+            });
+            WebsocetService_1.WebSocketService.getInstance().initialize(this.wss);
+        }
+        this.app = app;
+        this.logConfig();
+    }
+    logConfig() {
+        console.log(`
+╔════════════════════════════════════════╗
+║  🚀 Server Configuration               
+╠════════════════════════════════════════╣
+║  📍 Host: ${this.config.host}                       
+║  🔌 Port: ${this.config.port}                         
+║  🔌 Websocket: ${!!this.config.websocket}                         
+║  🔧 Middlewares: ${this.config.globalMiddlewares?.length || 0}                   
+║  🎯 Interceptors: ${this.config.globalInterceptors?.length || 0}                   
+║  📦 Controllers: ${this.config.controllers?.length || 0}                   
+╚════════════════════════════════════════╝
+    `);
+    }
+    async listen(port, host) {
+        if (this.isRunning) {
+            console.log('⚠️ Server is already running');
+            return this.app;
+        }
+        const listenPort = port || this.config.port || 3000;
+        const listenHost = host || this.config.host || 'localhost';
+        return new Promise((resolve, reject) => {
+            try {
+                this.app.listen(listenPort, listenHost, () => {
+                    this.isRunning = true;
+                    console.log(`
+╔════════════════════════════════════════╗
+║  🎉 Server started successfully!       
+║  📍 http://${listenHost}:${listenPort}  
+║  📊 Status: RUNNING                    
+╚════════════════════════════════════════╝
+          `);
+                    resolve(this.app);
+                });
+                this.app.on('error', (error) => {
+                    console.error('❌ Server error:', error);
+                    reject(error);
+                });
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    async close() {
+        return new Promise((resolve, reject) => {
+            if (!this.isRunning) {
+                resolve();
+                return;
+            }
+            this.app.close((err) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    this.isRunning = false;
+                    console.log(_constants_1.STOPPED);
+                    resolve();
+                }
+            });
+        });
+    }
+    status() {
+        return {
+            running: this.isRunning,
+            config: this.config,
+        };
+    }
+    async requestHandler(req, res) {
+        const startTime = Date.now();
+        try {
+            const request = await this.createRequest(req);
+            let processedRequest = await this.applyMiddlewares(request, res);
+            const data = await this.findController(processedRequest, res);
+            const finalResponse = await this.applyInterceptors(data, request, res);
+            await this.sendResponse(res, finalResponse, startTime);
+        }
+        catch (error) {
+            await this.handleError(error, req, res, startTime);
+        }
+    }
+    async createRequest(req) {
+        const rawBody = await (0, _utils_1.collectRawBody)(req);
+        const parseRequest = {
+            body: rawBody,
+            headers: req.headers,
+            isBase64Encoded: false,
+        };
+        const parsedBody = (0, _utils_1.ParseBody)(parseRequest);
+        const protocol = req.headers['x-forwarded-proto'] || 'http';
+        const host = req.headers.host || 'localhost';
+        const fullUrl = `${protocol}://${host}${req.url}`;
+        const whatwgUrl = new URL(fullUrl);
+        return {
+            method: req.method,
+            url: whatwgUrl,
+            path: whatwgUrl.pathname,
+            headers: req.headers,
+            body: parsedBody,
+            rawBody: rawBody,
+            query: (0, _utils_1.ParseQuery)(whatwgUrl),
+            params: {},
+            cookies: (0, _utils_1.ParseCookies)(req),
+            isBase64Encoded: false,
+            _startTime: Date.now(),
+        };
+    }
+    async applyMiddlewares(request, res) {
+        let processed = request;
+        for (const middleware of this.config.globalMiddlewares || []) {
+            const result = await middleware(processed, res);
+            if (result) {
+                processed = { ...processed, ...result };
+            }
+        }
+        return processed;
+    }
+    async findController(request, response) {
+        for (const ControllerClass of this.config.controllers || []) {
+            const instance = new ControllerClass();
+            if (typeof instance.handleRequest === 'function') {
+                const data = await instance.handleRequest(request, response);
+                if (data && data.status !== 404) {
+                    return data;
+                }
+            }
+        }
+        return {
+            status: 404,
+            data: { message: `Route ${request.method} ${request.path} not found` },
+        };
+    }
+    async applyInterceptors(data, request, response) {
+        let processed = data;
+        for (const interceptor of this.config.globalInterceptors || []) {
+            processed = await interceptor(processed, request, response);
+        }
+        return processed;
+    }
+    async sendResponse(res, data, startTime) {
+        const resp = data?.data !== undefined ? data.data : data;
+        if (!res.headersSent) {
+            if (!res.getHeader('Content-Type')) {
+                res.setHeader('Content-Type', 'application/json');
+            }
+            if (data?.headers) {
+                Object.entries(data.headers).forEach(([key, value]) => {
+                    if (!res.getHeader(key)) {
+                        res.setHeader(key, value);
+                    }
+                });
+            }
+        }
+        res.setHeader('X-Response-Time', `${Date.now() - startTime}ms`);
+        res.statusCode = data.status ?? 200;
+        res.end(JSON.stringify(resp));
+    }
+    async handleError(error, req, res, startTime) {
+        let errorResponse = {
+            status: error.status || 500,
+            data: {
+                message: error.message || 'Internal Server Error',
+                errors: error.errors || [],
+            },
+        };
+        if (!this.config.globalErrorHandler) {
+            return this.sendResponse(res, errorResponse, startTime);
+        }
+        try {
+            const intercepted = await this.config.globalErrorHandler(error, req, res);
+            errorResponse = { ...errorResponse, ...intercepted };
+        }
+        catch (cathed) {
+            Object.assign(errorResponse, cathed);
+        }
+        return this.sendResponse(res, errorResponse, startTime);
+    }
+}
+exports.HttpServer = HttpServer;

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

@@ -0,0 +1,16 @@
+import { WebSocketServer } from './websocket/WebsocketServer';
+export declare class Socket {
+    protected wss: WebSocketServer;
+    registerWebSocketControllers(controllers: any[]): this;
+    sendToClient(clientId: string, message: any): boolean;
+    publishToTopic(topic: string, data: any): void;
+    broadcast(message: any, excludeClientId?: string): void;
+    getWebSocketStats(): {
+        clients: number;
+        topics: {
+            topic: string;
+            subscribers: number;
+        }[];
+    };
+    isWebSocketAvailable(): boolean;
+}

package/dist/app/http/Socket.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Socket = void 0;
+const WebsocetService_1 = require("./websocket/WebsocetService");
+class Socket {
+    wss;
+    registerWebSocketControllers(controllers) {
+        if (!this.wss) {
+            console.warn('⚠️ WebSocket is disabled. Enable it in config: { websocket: { enabled: true } }');
+            return this;
+        }
+        this.wss.registerControllers(controllers);
+        console.log(`📝 Registered ${controllers.length} WebSocket controllers`);
+        return this;
+    }
+    sendToClient(clientId, message) {
+        return WebsocetService_1.WebSocketService.getInstance().sendToClient(clientId, message);
+    }
+    publishToTopic(topic, data) {
+        WebsocetService_1.WebSocketService.getInstance().publishToTopic(topic, data);
+    }
+    broadcast(message, excludeClientId) {
+        WebsocetService_1.WebSocketService.getInstance().broadcast(message, excludeClientId);
+    }
+    getWebSocketStats() {
+        return WebsocetService_1.WebSocketService.getInstance().getStats();
+    }
+    isWebSocketAvailable() {
+        return WebsocetService_1.WebSocketService.getInstance().isAvailable();
+    }
+}
+exports.Socket = Socket;

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

@@ -0,0 +1,7 @@
+import { Conf, Interceptor } from '@types';
+export declare function Server(config?: Conf): (target: any) => any;
+export declare function Use(middleware: any): (target: any) => any;
+export declare function Intercept(interceptor: Interceptor): (target: any) => any;
+export declare function Catch(handler: any): (target: any) => any;
+export declare function Port(port: number): (target: any) => any;
+export declare function Host(host: string): (target: any) => any;