quantum-flow 1.0.1

package/src/app/aws/lambda.ts

@@ -0,0 +1,283 @@
+import { OK_STATUSES } from '@constants';
+import { ParseBody } from '@utils';
+import {
+  APIGatewayProxyEvent,
+  APIGatewayProxyEventHeaders,
+  APIGatewayProxyEventPathParameters,
+  APIGatewayProxyResult,
+  Context,
+  Handler,
+} from 'aws-lambda';
+
+import { LambdaRequest, LambdaResponse } from '@types';
+
+export class LambdaAdapter {
+  private static getHeaderValue(headers: any, headerName: string): string | undefined {
+    const value = headers?.[headerName] || headers?.[headerName.toLowerCase()];
+
+    if (!value) return undefined;
+
+    if (Array.isArray(value)) {
+      return value[0];
+    }
+
+    return value;
+  }
+  static toRequest(event: APIGatewayProxyEvent, context: Context): LambdaRequest {
+    const query: Record<string, string | string[]> = {};
+    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: Record<string, string> = {};
+    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 = 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: 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: any) {
+    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 as LambdaResponse;
+      } else {
+        body = {
+          data: response,
+          timestamp: new Date().toISOString(),
+        };
+      }
+    }
+
+    return body;
+  }
+
+  static toLambdaResponse(response: any, request?: LambdaRequest): LambdaResponse {
+    let statusCode = response.status ?? 200;
+
+    let body: any = this.createResponseBody(response);
+    let headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+      'X-Request-Id': request?.requestId || 'unknown',
+      'X-Powered-By': 'Lambda Decorators',
+    };
+
+    const cookies: string[] = [];
+
+    if (response && typeof response === 'object') {
+      if ('data' in response) {
+        body = {
+          success: OK_STATUSES.includes(statusCode),
+          data: response.data,
+          timestamp: new Date().toISOString(),
+          requestId: request?.requestId,
+        };
+      } else if (response.body) {
+        return response as LambdaResponse;
+      } else {
+        body = {
+          success: 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: 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: any) {
+    const handler: Handler<APIGatewayProxyEvent, APIGatewayProxyResult> = 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: any) {
+        console.error('❌ Lambda error:', error);
+
+        const errorResponse: any = {
+          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;
+  }
+
+  private static safeHeaders(
+    headers: APIGatewayProxyEventHeaders,
+  ): Record<string, string | string[]> {
+    const result: Record<string, string | string[]> = {};
+
+    if (!headers) return result;
+
+    Object.entries(headers).forEach(([key, value]) => {
+      if (value !== undefined) {
+        result[key] = value;
+      }
+    });
+
+    return result;
+  }
+
+  private static safeParams(
+    params: APIGatewayProxyEventPathParameters | null,
+  ): Record<string, string> {
+    const result: Record<string, string> = {};
+
+    if (!params) return result;
+
+    Object.entries(params).forEach(([key, value]) => {
+      if (value !== undefined) {
+        result[key] = value;
+      }
+    });
+
+    return result;
+  }
+
+  private static getSourceIp(event: APIGatewayProxyEvent): string {
+    if (event.requestContext?.identity?.sourceIp) {
+      return event.requestContext.identity.sourceIp;
+    }
+
+    const forwardedFor: any = 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';
+  }
+
+  private static getUserAgent(event: APIGatewayProxyEvent): string {
+    const ua: any = 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';
+  }
+}

package/src/app/http/Application.ts

@@ -0,0 +1,250 @@
+import { STOPPED } from '@constants';
+import { ServerConfig } from '@types';
+import { collectRawBody, ParseBody, ParseCookies, ParseQuery, resolveConfig } from '@utils';
+import http, { ServerResponse } from 'http';
+import { Socket } from './Socket';
+import { WebSocketService } from './websocket/WebsocetService';
+import { WebSocketServer } from './websocket/WebsocketServer';
+
+export class HttpServer extends Socket {
+  private app: http.Server;
+  private config: ServerConfig;
+  private isRunning: boolean = false;
+
+  constructor(configOrClass: new (...args: any[]) => any) {
+    super();
+    this.config = resolveConfig(configOrClass);
+
+    const app = http.createServer(this.requestHandler.bind(this));
+
+    if (this.config.websocket?.enabled) {
+      this.wss = new WebSocketServer(app, {
+        path: this.config.websocket.path || '/',
+      });
+      WebSocketService.getInstance().initialize(this.wss);
+    }
+
+    this.app = app;
+
+    this.logConfig();
+  }
+
+  private 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}                   
+╚════════════════════════════════════════╝
+    `);
+  }
+
+  public async listen(port?: number, host?: string): Promise<http.Server> {
+    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);
+      }
+    });
+  }
+
+  public async close(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      if (!this.isRunning) {
+        resolve();
+        return;
+      }
+
+      this.app.close((err) => {
+        if (err) {
+          reject(err);
+        } else {
+          this.isRunning = false;
+          console.log(STOPPED);
+          resolve();
+        }
+      });
+    });
+  }
+
+  public status(): { running: boolean; config: ServerConfig } {
+    return {
+      running: this.isRunning,
+      config: this.config,
+    };
+  }
+
+  private async requestHandler(req: http.IncomingMessage, res: ServerResponse) {
+    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);
+    }
+  }
+
+  private async createRequest(req: http.IncomingMessage): Promise<any> {
+    const rawBody = await collectRawBody(req);
+
+    const parseRequest = {
+      body: rawBody,
+      headers: req.headers,
+      isBase64Encoded: false,
+    };
+
+    const parsedBody = 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: ParseQuery(whatwgUrl),
+      params: {},
+      cookies: ParseCookies(req),
+      isBase64Encoded: false,
+      _startTime: Date.now(),
+    };
+  }
+
+  private async applyMiddlewares(request: any, res: http.ServerResponse): Promise<any> {
+    let processed = request;
+
+    for (const middleware of this.config.globalMiddlewares || []) {
+      const result = await middleware(processed, res);
+      if (result) {
+        processed = { ...processed, ...result };
+      }
+    }
+
+    return processed;
+  }
+
+  private async findController(request: any, response?: ServerResponse): Promise<any> {
+    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` },
+    };
+  }
+
+  private async applyInterceptors(
+    data: any,
+    request: Request,
+    response: ServerResponse,
+  ): Promise<any> {
+    let processed = data;
+
+    for (const interceptor of this.config.globalInterceptors || []) {
+      processed = await interceptor(processed, request, response);
+    }
+
+    return processed;
+  }
+
+  private async sendResponse(
+    res: http.ServerResponse,
+    data: any,
+    startTime: number,
+  ): Promise<void> {
+    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 as string);
+          }
+        });
+      }
+    }
+    res.setHeader('X-Response-Time', `${Date.now() - startTime}ms`);
+    res.statusCode = data.status ?? 200;
+
+    res.end(JSON.stringify(resp));
+  }
+
+  private async handleError(
+    error: any,
+    req: http.IncomingMessage,
+    res: http.ServerResponse,
+    startTime: number,
+  ): Promise<void> {
+    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);
+  }
+}

package/src/app/http/Socket.ts

@@ -0,0 +1,38 @@
+import { WebSocketService } from './websocket/WebsocetService';
+import { WebSocketServer } from './websocket/WebsocketServer';
+
+export class Socket {
+  protected wss: WebSocketServer;
+
+  public registerWebSocketControllers(controllers: any[]) {
+    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;
+  }
+
+  public sendToClient(clientId: string, message: any): boolean {
+    return WebSocketService.getInstance().sendToClient(clientId, message);
+  }
+
+  public publishToTopic(topic: string, data: any) {
+    WebSocketService.getInstance().publishToTopic(topic, data);
+  }
+
+  public broadcast(message: any, excludeClientId?: string) {
+    WebSocketService.getInstance().broadcast(message, excludeClientId);
+  }
+
+  public getWebSocketStats() {
+    return WebSocketService.getInstance().getStats();
+  }
+
+  public isWebSocketAvailable(): boolean {
+    return WebSocketService.getInstance().isAvailable();
+  }
+}

package/src/app/http/decorators.ts

@@ -0,0 +1,115 @@
+import { SERVER_CONFIG_KEY, SERVER_MODULES_KEY } from '@constants';
+
+import { Conf, Interceptor } from '@types';
+
+export function Server(config: Conf = {}) {
+  return function (target: any) {
+    const existingConfig = Reflect.getMetadata(SERVER_CONFIG_KEY, target) || {};
+
+    const mergedConfig = {
+      ...existingConfig,
+      ...config,
+      controllers: [...(existingConfig.controllers || []), ...(config.controllers || [])],
+      globalMiddlewares: existingConfig.globalMiddlewares || config.globalMiddlewares,
+      globalInterceptors: existingConfig.globalInterceptors || config.globalInterceptors || [],
+    };
+
+    Reflect.defineMetadata(SERVER_CONFIG_KEY, mergedConfig, target);
+
+    if (config.controllers) {
+      Reflect.defineMetadata(SERVER_MODULES_KEY, config.controllers, target);
+    }
+
+    return target;
+  };
+}
+
+export function Use(middleware: any) {
+  return function (target: any) {
+    const existingConfig = Reflect.getMetadata(SERVER_CONFIG_KEY, target) || {};
+    const middlewares = existingConfig.globalMiddlewares || [];
+
+    middlewares.push(middleware);
+    console.log(middlewares);
+    Reflect.defineMetadata(
+      SERVER_CONFIG_KEY,
+      {
+        ...existingConfig,
+        globalMiddlewares: middlewares,
+      },
+      target,
+    );
+
+    return target;
+  };
+}
+
+export function Intercept(interceptor: Interceptor) {
+  return function (target: any) {
+    const existingConfig = Reflect.getMetadata(SERVER_CONFIG_KEY, target) || {};
+    const interceptors = existingConfig.globalInterceptors || [];
+
+    interceptors.push(interceptor);
+
+    Reflect.defineMetadata(
+      SERVER_CONFIG_KEY,
+      {
+        ...existingConfig,
+        globalInterceptors: interceptors,
+      },
+      target,
+    );
+
+    return target;
+  };
+}
+
+export function Catch(handler: any) {
+  return function (target: any) {
+    const existingConfig = Reflect.getMetadata(SERVER_CONFIG_KEY, target) || {};
+
+    Reflect.defineMetadata(
+      SERVER_CONFIG_KEY,
+      {
+        ...existingConfig,
+        globalErrorHandler: handler,
+      },
+      target,
+    );
+
+    return target;
+  };
+}
+
+export function Port(port: number) {
+  return function (target: any) {
+    const existingConfig = Reflect.getMetadata(SERVER_CONFIG_KEY, target) || {};
+
+    Reflect.defineMetadata(
+      SERVER_CONFIG_KEY,
+      {
+        ...existingConfig,
+        port,
+      },
+      target,
+    );
+
+    return target;
+  };
+}
+export function Host(host: string) {
+  return function (target: any) {
+    const existingConfig = Reflect.getMetadata(SERVER_CONFIG_KEY, target) || {};
+
+    Reflect.defineMetadata(
+      SERVER_CONFIG_KEY,
+      {
+        ...existingConfig,
+        host,
+      },
+      target,
+    );
+
+    return target;
+  };
+}

package/src/app/http/index.ts

@@ -0,0 +1,3 @@
+export * from './Application';
+export * from './decorators';
+export * from './websocket/WebsocketServer';