quantum-flow 1.0.1

package/src/core/utils/websocket.ts

@@ -0,0 +1,45 @@
+import { WS_METADATA_KEY, WS_SERVICE_KEY, WS_TOPIC_KEY } from '@constants';
+
+import { WebSocketHandlerType } from '@types';
+
+export function OnWS(type: WebSocketHandlerType, topic?: string) {
+  return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
+    const handlers = Reflect.getMetadata(WS_METADATA_KEY, target.constructor) || [];
+    handlers.push({ type, topic, method: propertyKey });
+    Reflect.defineMetadata(WS_METADATA_KEY, handlers, target.constructor);
+    return descriptor;
+  };
+}
+
+export function OnConnection() {
+  return OnWS('connection');
+}
+
+export function OnMessage(topic?: string) {
+  return OnWS('message', topic);
+}
+
+export function OnClose() {
+  return OnWS('close');
+}
+
+export function OnError() {
+  return OnWS('error');
+}
+
+export function Subscribe(topic: string) {
+  return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
+    const topics = Reflect.getMetadata(WS_TOPIC_KEY, target.constructor) || [];
+    topics.push({ topic, method: propertyKey });
+    Reflect.defineMetadata(WS_TOPIC_KEY, topics, target.constructor);
+    return descriptor;
+  };
+}
+
+export function InjectWS() {
+  return function (target: any, propertyKey: string, parameterIndex: number) {
+    const existingParams = Reflect.getMetadata(WS_SERVICE_KEY, target, propertyKey) || [];
+    existingParams.push({ index: parameterIndex });
+    Reflect.defineMetadata(WS_SERVICE_KEY, existingParams, target, propertyKey);
+  };
+}

package/src/types/common.ts

@@ -0,0 +1,60 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { IncomingHttpHeaders, ServerResponse } from 'http';
+
+type P_Q = Record<string, string | undefined> | null | unknown;
+
+export type Request<B = unknown, Q extends P_Q = unknown, P extends P_Q = unknown> = {
+  method: string;
+  url: URL;
+  headers: IncomingHttpHeaders;
+  query?: Q;
+  params?: P;
+  body: B;
+  isBase64Encoded?: boolean;
+};
+export type Router = (
+  req: Request,
+  res?: ServerResponse,
+) => Promise<{ status: number; data: any; message?: string }>;
+
+export type EndpointResponse<T = any> = {
+  status: number;
+  data?: T;
+  error?: any;
+};
+
+export type AxiosQuery = {
+  data?: { [key: string]: any };
+  headers?: { [key: string]: any };
+  params?: { [key: string]: any };
+  url: string;
+  method: 'POST' | 'GET' | 'PATCH' | 'DELETE';
+};
+
+export interface IController {
+  handleRequest: Router;
+}
+
+export type Middleware = (req: Request, res?: ServerResponse) => Promise<Request> | Request;
+export type Interceptor = (
+  data: any,
+  req?: Request,
+  res?: ServerResponse,
+) => Promise<unknown> | unknown;
+
+export type ParamDecoratorType =
+  | 'body'
+  | 'params'
+  | 'query'
+  | 'request'
+  | 'headers'
+  | 'cookies'
+  | 'response'
+  | 'multipart';
+
+export interface ParamMetadata {
+  index: number;
+  type: ParamDecoratorType;
+  dto?: any;
+  name?: string;
+}

package/src/types/controller.ts

@@ -0,0 +1,2 @@
+export type ControllerClass = { new (...args: any[]): any };
+export type ControllerInstance = InstanceType<ControllerClass>;

package/src/types/http.ts

@@ -0,0 +1,19 @@
+export interface ServerConfig {
+  port?: number;
+  host?: string;
+  globalMiddlewares?: any[];
+  globalInterceptors?: any[];
+  globalErrorHandler?: any;
+  controllers?: any[];
+  websocket?: {
+    enabled: boolean;
+    path?: string;
+    lazy?: boolean;
+  };
+}
+
+export type Conf = ServerConfig & {
+  globalMiddlewares?: any[];
+  globalInterceptors?: any[];
+  globalErrorHandler?: any;
+};

package/src/types/index.ts

@@ -0,0 +1,5 @@
+export * from './common';
+export * from './controller';
+export * from './http';
+export * from './lambda';
+export * from './websocket';

package/src/types/lambda.ts

@@ -0,0 +1,28 @@
+import { APIGatewayProxyEvent, Context } from 'aws-lambda';
+
+export interface LambdaRequest {
+  method: string;
+  path: string;
+  headers: Record<string, string | string[]>;
+  query: Record<string, string | string[]>;
+  body: any;
+  params: Record<string, string>;
+  cookies: Record<string, string>;
+  raw: APIGatewayProxyEvent;
+  context: Context;
+  isBase64Encoded: boolean;
+  requestId: string;
+  stage: string;
+  sourceIp: string;
+  userAgent: string;
+  url: URL;
+}
+
+export interface LambdaResponse {
+  statusCode: number;
+  headers?: Record<string, string>;
+  body: string;
+  isBase64Encoded?: boolean;
+  multiValueHeaders?: Record<string, string[]>;
+  cookies?: string[];
+}

package/src/types/websocket.ts

@@ -0,0 +1,57 @@
+import WebSocket from 'ws';
+
+export type WebSocketHandlerType = 'connection' | 'message' | 'close' | 'error';
+
+export interface WebSocketMessage {
+  type: string;
+  topic?: string;
+  data: any;
+  clientId?: string;
+}
+
+export interface WebSocketEvent {
+  type: WebSocketHandlerType;
+  client: WebSocketClient;
+  message?: WebSocketMessage;
+  data?: any;
+}
+
+export interface WebSocketClient {
+  id: string;
+  socket: WebSocket;
+  topics: Set<string>;
+  data: Record<string, any>;
+  connectedAt: Date;
+}
+
+export interface WebSocketMessage {
+  type: string;
+  topic?: string;
+  data: any;
+  clientId?: string;
+}
+
+export interface WebSocketStats {
+  clients: number;
+  topics: Array<{
+    topic: string;
+    subscribers: number;
+  }>;
+}
+
+export interface IWebSocketService {
+  sendToClient(clientId: string, message: any): boolean;
+  publishToTopic(topic: string, data: any, exclude?: string[]): void;
+  broadcast(message: any, excludeClientId?: string): void;
+  getStats(): { clients: number; topics: Array<{ topic: string; subscribers: number }> };
+  isAvailable(): boolean;
+}
+
+export interface IWebSocketServer {
+  sendToClient(clientId: string, message: any): boolean;
+  publishToTopic(topic: string, data: any, exclude: string[]): void;
+  broadcast(message: any, excludeClientId?: string): void;
+  getStats(): WebSocketStats;
+  subscribeToTopic(client: WebSocketClient, topic: string): void;
+  unsubscribeFromTopic(client: WebSocketClient, topic: string): void;
+}

package/src/utils/controller.ts

@@ -0,0 +1,143 @@
+import { ControllerInstance, Middleware, ParamMetadata } from '@types';
+import { MultipartProcessor } from '@utils';
+import { WebSocketService } from '../app/http/websocket/WebsocetService';
+import { validate } from './validate';
+
+import { ENDPOINT, MIDDLEWARES, PARAM_METADATA_KEY, TO_VALIDATE, WS_SERVICE_KEY } from '@constants';
+import { ServerResponse } from 'http';
+
+const getBodyAndMultipart = (payload: any) => {
+  let body = payload.body;
+  let multipart;
+  if (MultipartProcessor.isMultipart({ headers: payload.headers })) {
+    try {
+      const { fields, files } = MultipartProcessor.parse({
+        body: payload.rawBody || payload.body,
+        headers: payload.headers,
+        isBase64Encoded: payload.isBase64Encoded,
+      });
+      multipart = files;
+      body = fields;
+    } catch (error) {
+      console.error('❌ Multipart parsing error:', error);
+      throw { status: 400, message: 'Invalid multipart data' };
+    }
+  }
+
+  return { multipart, body };
+};
+
+export const executeControllerMethod = async (
+  controller: ControllerInstance,
+  propertyName: string,
+  payload: any,
+  response?: ServerResponse,
+) => {
+  const fn = controller[propertyName];
+  if (typeof fn !== 'function') return null;
+  const endpointMeta = Reflect.getMetadata(ENDPOINT, controller, propertyName);
+  if (!endpointMeta) return null;
+
+  const methodMiddlewares: Middleware[] =
+    Reflect.getMetadata(MIDDLEWARES, controller, propertyName) || [];
+
+  for (let i = 0; i < methodMiddlewares.length; i++) {
+    const middleware = methodMiddlewares[i];
+    const result = await middleware(payload);
+    if (result) {
+      payload = { ...payload, ...result };
+    }
+  }
+
+  const prototype = Object.getPrototypeOf(controller);
+  const paramMetadata: ParamMetadata[] =
+    Reflect.getMetadata(PARAM_METADATA_KEY, prototype, propertyName) || [];
+
+  const { body, multipart } = getBodyAndMultipart(payload);
+  if (paramMetadata.length === 0) {
+    return fn.call(controller, payload);
+  }
+
+  const args: any[] = [];
+
+  const wsParams = Reflect.getMetadata(WS_SERVICE_KEY, controller, propertyName) || [];
+  const totalParams = Math.max(
+    paramMetadata.length ? Math.max(...paramMetadata.map((p) => p.index)) + 1 : 0,
+    wsParams.length ? Math.max(...wsParams.map((p: any) => p.index)) + 1 : 0,
+  );
+
+  for (let i = 0; i < totalParams; i++) {
+    const wsParam = wsParams.find((p: any) => p.index === i);
+    if (wsParam) {
+      args[i] = WebSocketService.getInstance();
+      continue;
+    }
+
+    const param = paramMetadata.find((p) => p.index === i);
+    if (!param) {
+      args[i] = undefined;
+      continue;
+    }
+
+    let value = param.name ? payload[param.type]?.[param.name] : payload[param.type];
+
+    if (param.type === 'multipart') {
+      value = multipart;
+    }
+    if (param.type === 'request') {
+      value = payload;
+    }
+    if (param.type === 'response') {
+      value = response;
+    }
+    if (param.type === 'response') {
+      value = response;
+    }
+    if (param.type === 'body') {
+      value = body;
+    }
+
+    if (TO_VALIDATE.includes(param.type)) {
+      value = await validate(param.dto, value);
+    }
+
+    args[i] = value;
+  }
+
+  return fn.apply(controller, args);
+};
+
+export const getControllerMethods = (controller: ControllerInstance) => {
+  const methods: Array<{
+    name: string;
+    httpMethod: string;
+    pattern: string;
+    middlewares?: Array<(req: any, res?: ServerResponse) => any>;
+  }> = [];
+
+  let proto = Object.getPrototypeOf(controller);
+
+  while (proto && proto !== Object.prototype) {
+    const propertyNames = Object.getOwnPropertyNames(proto);
+    for (const propertyName of propertyNames) {
+      if (propertyName === 'constructor') continue;
+
+      const endpointMeta = Reflect.getMetadata(ENDPOINT, proto, propertyName);
+
+      if (endpointMeta) {
+        const [httpMethod, pattern] = endpointMeta;
+        const methodMiddlewares = Reflect.getMetadata(MIDDLEWARES, proto, propertyName);
+
+        methods.push({
+          name: propertyName,
+          httpMethod,
+          pattern,
+          middlewares: methodMiddlewares,
+        });
+      }
+    }
+    proto = Object.getPrototypeOf(proto);
+  }
+
+  return methods;
+};

package/src/utils/helper.ts

@@ -0,0 +1,24 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+export const matchRoute = (routePattern: string, actualPath: string) => {
+  const routeParts = routePattern.split('/').filter(Boolean);
+  const pathParts = actualPath.split('/').filter(Boolean);
+
+  if (routeParts.length !== pathParts.length) return null;
+
+  const params: Record<string, string> = {};
+
+  for (let i = 0; i < routeParts.length; i++) {
+    const routePart = routeParts[i];
+    const pathPart = pathParts[i];
+
+    if (routePart.startsWith(':')) {
+      const paramName = routePart.slice(1);
+      params[paramName] = decodeURIComponent(pathPart);
+    } else if (routePart !== pathPart) {
+      return null;
+    }
+  }
+
+  return params;
+};

package/src/utils/index.ts

@@ -0,0 +1,7 @@
+export * from './controller';
+export * from './helper';
+export * from './multipart';
+export * from './parsers';
+export * from './server';
+export * from './transform';
+export * from './validate';

package/src/utils/multipart.ts

@@ -0,0 +1,93 @@
+// utils/MultipartProcessor.ts
+import * as multipart from 'parse-multipart-data';
+
+export interface MultipartFile {
+  fieldname: string;
+  filename: string;
+  contentType: string;
+  data: Buffer;
+  size: number;
+  encoding?: string;
+}
+
+export class MultipartProcessor {
+  static parse(request: any): {
+    fields: Record<string, any>;
+    files: Record<string, MultipartFile | MultipartFile[]>;
+  } {
+    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: Buffer;
+    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: Record<string, any> = {};
+    const files: Record<string, MultipartFile | MultipartFile[]> = {};
+
+    parts.forEach((part: any) => {
+      if (part.filename) {
+        const fieldName = part.name || 'file';
+
+        const fileData: MultipartFile = {
+          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] as MultipartFile[]).push(fileData);
+          } else {
+            files[fieldName] = [files[fieldName] as MultipartFile, 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: any): boolean {
+    const contentType =
+      request.headers?.['content-type'] || request.headers?.['Content-Type'] || '';
+    return contentType.startsWith('multipart/form-data');
+  }
+}

package/src/utils/parsers.ts

@@ -0,0 +1,87 @@
+import http from 'http';
+export const ParseQuery = (url: URL) => {
+  const params = url.searchParams;
+  const query: Record<string, string | string[]> = {};
+
+  for (const key of params.keys()) {
+    const values = params.getAll(key);
+
+    query[key] = values.length > 1 ? values : values[0];
+  }
+
+  return query;
+};
+
+export const ParseBody = (request: any): any => {
+  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: Record<string, any> = {};
+      params.forEach((value, key) => {
+        result[key] = value;
+      });
+      return result;
+    }
+  }
+
+  if (Buffer.isBuffer(body)) {
+    return { raw: body.toString('utf8') };
+  }
+
+  return body;
+};
+
+export const ParseCookies = (req: http.IncomingMessage): Record<string, string> => {
+  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;
+    },
+    {} as Record<string, string>,
+  );
+};

package/src/utils/server.ts

@@ -0,0 +1,49 @@
+import { SERVER_CONFIG_KEY, SERVER_MODULES_KEY } from '@constants';
+import { ServerConfig } from '@types';
+import http from 'http';
+
+export const resolveConfig = (configOrClass?: any): ServerConfig => {
+  let config: ServerConfig = {};
+
+  if (configOrClass && typeof configOrClass === 'function') {
+    const decoratorConfig = Reflect.getMetadata(SERVER_CONFIG_KEY, configOrClass) || {};
+    const controllers = Reflect.getMetadata(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;
+};
+
+export const collectRawBody = (req: http.IncomingMessage): Promise<Buffer> => {
+  return new Promise((resolve) => {
+    const chunks: Buffer[] = [];
+
+    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(''));
+    });
+  });
+};

package/src/utils/transform.ts

@@ -0,0 +1,24 @@
+export async function transformAndValidate(dtoClass: any, data: any) {
+  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;
+}