@heliosjs/core 1.0.2

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Re-exports core decorators and types related to controllers and endpoints.
+ *
+ * This module provides centralized exports for controller and endpoint decorators,
+ * as well as related types and utility functions used throughout the core framework.
+ */
+export * from './Controller';
+export * from './decorators';
+export * from './Endpoint';
+export { AppError, CORSConfig, ErrorCB, InterceptorCB, IRequest, IResponse, MiddlewareCB, MultipartFile, SanitizerConfig, } from './types/core';
+export { SANITIZER } from './utils/core';

package/dist/index.js

@@ -0,0 +1,29 @@
+"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 });
+exports.SANITIZER = void 0;
+/**
+ * Re-exports core decorators and types related to controllers and endpoints.
+ *
+ * This module provides centralized exports for controller and endpoint decorators,
+ * as well as related types and utility functions used throughout the core framework.
+ */
+__exportStar(require("./Controller"), exports);
+__exportStar(require("./decorators"), exports);
+__exportStar(require("./Endpoint"), exports);
+var core_1 = require("./utils/core");
+Object.defineProperty(exports, "SANITIZER", { enumerable: true, get: function () { return core_1.SANITIZER; } });
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA;;;;;GAKG;AACH,+CAA6B;AAC7B,+CAA6B;AAC7B,6CAA2B;AAY3B,qCAAyC;AAAhC,iGAAA,SAAS,OAAA"}

package/dist/types/core/common.d.ts

@@ -0,0 +1,44 @@
+import { ServerResponse } from 'http';
+import { AppError } from './error';
+import { IRequest } from './request';
+import { IResponse } from './response';
+export type Router = (req: IRequest, res?: ServerResponse) => Promise<{
+    status: number;
+    data: any;
+    message?: string;
+}>;
+export interface IController {
+    handleRequest: Router;
+}
+export type MiddlewareCB = (request: IRequest, response: IResponse, next: (args?: any) => any) => void | Promise<IRequest> | IRequest | Promise<void> | void;
+export type InterceptorCB = (data: any, req?: IRequest, res?: IResponse) => Promise<unknown> | unknown;
+export type ErrorCB = (error: AppError, req?: IRequest, res?: IResponse) => any;
+export type ParamDecoratorType = 'body' | 'params' | 'query' | 'request' | 'headers' | 'cookies' | 'response' | 'multipart' | 'event' | 'context' | 'sse' | 'ws';
+export interface ParamMetadata {
+    index: number;
+    type: ParamDecoratorType;
+    dto?: any;
+    name?: string;
+}
+export type ResponseWithStatus = {
+    status: number;
+    [key: string]: any;
+};
+export declare enum HTTP_METHODS {
+    ANY = "ANY",
+    GET = "GET",
+    POST = "POST",
+    PATCH = "PATCH",
+    DELETE = "DELETE",
+    PUT = "PUT",
+    OPTIONS = "OPTIONS",
+    HEAD = "HEAD"
+}
+export type Meta = {
+    requestUrl: URL;
+    method: string;
+    requestId: string;
+    sourceIp: string;
+    userAgent: string;
+    startTime: number;
+};

package/dist/types/core/common.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HTTP_METHODS = void 0;
+var HTTP_METHODS;
+(function (HTTP_METHODS) {
+    HTTP_METHODS["ANY"] = "ANY";
+    HTTP_METHODS["GET"] = "GET";
+    HTTP_METHODS["POST"] = "POST";
+    HTTP_METHODS["PATCH"] = "PATCH";
+    HTTP_METHODS["DELETE"] = "DELETE";
+    HTTP_METHODS["PUT"] = "PUT";
+    HTTP_METHODS["OPTIONS"] = "OPTIONS";
+    HTTP_METHODS["HEAD"] = "HEAD";
+})(HTTP_METHODS || (exports.HTTP_METHODS = HTTP_METHODS = {}));
+//# sourceMappingURL=common.js.map

package/dist/types/core/common.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.js","sourceRoot":"","sources":["../../../src/types/core/common.ts"],"names":[],"mappings":";;;AAsDA,IAAY,YASX;AATD,WAAY,YAAY;IACtB,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,6BAAa,CAAA;IACb,+BAAe,CAAA;IACf,iCAAiB,CAAA;IACjB,2BAAW,CAAA;IACX,mCAAmB,CAAA;IACnB,6BAAa,CAAA;AACf,CAAC,EATW,YAAY,4BAAZ,YAAY,QASvB"}

package/dist/types/core/controller.d.ts

@@ -0,0 +1,78 @@
+import { ServerResponse } from 'http';
+import { ErrorCB, HTTP_METHODS, InterceptorCB, MiddlewareCB } from './common';
+import { CORSConfig } from './cors';
+import { IRequest } from './request';
+import { SanitizerConfig } from './sanitize';
+export type ControllerClass = {
+    new (...args: any[]): any;
+};
+export type ControllerMethods = Array<{
+    name: string;
+    httpMethod: HTTP_METHODS;
+    pattern: string;
+    middlewares?: MiddlewareCB[];
+}>;
+export type ControllerType = {
+    handleRequest?(request: IRequest, response: ServerResponse): Promise<any>;
+    ws?: WsControllerHandlers;
+    sse?: SeeControllerHandlers;
+    new (...args: any[]): any;
+};
+export type ControllerInstance = InstanceType<ControllerType>;
+export type ControllerMetadata = {
+    routePrefix: string;
+    middlewares: MiddlewareCB[];
+    interceptor?: InterceptorCB;
+    subControllers: ControllerInstance[];
+    errorHandler?: ErrorCB;
+    cors?: CORSConfig;
+    sanitizers: SanitizerConfig[];
+};
+export interface ControllerConfig {
+    prefix: string;
+    middlewares?: Array<MiddlewareCB>;
+    controllers?: ControllerInstance[];
+    interceptor?: InterceptorCB;
+}
+export type RouteContext = {
+    controllerInstance: any;
+    controllerMeta: ControllerMetadata;
+    path: string;
+    method: string;
+    middlewareChain: MiddlewareCB[];
+    interceptorChain: InterceptorCB[];
+    corsChain: CORSConfig[];
+    errorHandlerChain: ErrorCB[];
+    subPath: string;
+    sanitizersChain: SanitizerConfig[];
+};
+export type SSE_HANDLER_META = {
+    type: string;
+    method: string;
+};
+export type HandlerMeta = {
+    type: 'connection';
+    topic: undefined;
+    method: 'onconnect';
+    fn: (...args: any[]) => any;
+};
+export type WsHandlerMeta = HandlerMeta & {
+    topic?: string;
+};
+export type WsControllerHandlers = {
+    handlers: {
+        connection: WsHandlerMeta[];
+        message: WsHandlerMeta[];
+        close: WsHandlerMeta[];
+        error: WsHandlerMeta[];
+    };
+    topics: HandlerMeta[];
+};
+export type SeeControllerHandlers = {
+    handlers: {
+        connection: HandlerMeta[];
+        close: HandlerMeta[];
+        error: HandlerMeta[];
+    };
+};
+export type NextFunction = (error?: unknown) => void;

package/dist/types/core/controller.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=controller.js.map

package/dist/types/core/controller.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"controller.js","sourceRoot":"","sources":["../../../src/types/core/controller.ts"],"names":[],"mappings":""}

package/dist/types/core/cors.d.ts

@@ -0,0 +1,10 @@
+export interface CORSConfig {
+    origin?: string | string[] | ((origin: string) => boolean);
+    methods?: string[];
+    allowedHeaders?: string[];
+    exposedHeaders?: string[];
+    credentials?: boolean;
+    maxAge?: number;
+    preflightContinue?: boolean;
+    optionsSuccessStatus?: number;
+}

package/dist/types/core/cors.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=cors.js.map

package/dist/types/core/cors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cors.js","sourceRoot":"","sources":["../../../src/types/core/cors.ts"],"names":[],"mappings":""}

package/dist/types/core/error.d.ts

@@ -0,0 +1,72 @@
+import { IRequest } from './request';
+import { IResponse } from './response';
+export declare enum ErrorCode {
+    BAD_REQUEST = "BAD_REQUEST",
+    UNAUTHORIZED = "UNAUTHORIZED",
+    FORBIDDEN = "FORBIDDEN",
+    NOT_FOUND = "NOT_FOUND",
+    VALIDATION_FAILED = "VALIDATION_FAILED",
+    RATE_LIMIT_EXCEEDED = "RATE_LIMIT_EXCEEDED",
+    INTERNAL_ERROR = "INTERNAL_ERROR",
+    SERVICE_UNAVAILABLE = "SERVICE_UNAVAILABLE",
+    DATABASE_ERROR = "DATABASE_ERROR",
+    DUPLICATE_ENTRY = "DUPLICATE_ENTRY",
+    INVALID_STATE = "INVALID_STATE",
+    DEPENDENCY_FAILED = "DEPENDENCY_FAILED"
+}
+export interface ErrorDetails {
+    field?: string;
+    value?: any;
+    constraint?: string;
+    [key: string]: any;
+}
+export interface AppError extends Error {
+    code: ErrorCode;
+    status: number;
+    details?: ErrorDetails[];
+    timestamp: Date;
+    requestId?: string;
+    path?: string;
+    method?: string;
+    toResponse(): ErrorResponse;
+}
+export interface IValidationError extends AppError {
+    code: ErrorCode.VALIDATION_FAILED;
+    details?: ErrorDetails[];
+}
+export interface ErrorResponse {
+    success: false;
+    error: {
+        code: ErrorCode;
+        status: number;
+        message: string;
+        details?: ErrorDetails[];
+        timestamp: string;
+        requestId?: string;
+        path?: string;
+    };
+}
+export interface ErrorHandlerConfig {
+    includeStack?: boolean;
+    logErrors?: boolean;
+    logStack?: boolean;
+    customHandlers?: Record<ErrorCode, (error: AppError) => any>;
+}
+export interface SerializedError {
+    type: 'Error' | 'HttpError' | 'AxiosError' | 'Unknown' | 'ValidationError';
+    message: string;
+    status?: number;
+    code?: string;
+    stack?: string;
+    data?: any;
+    original?: any;
+    errors?: any[];
+    details?: ErrorDetails[];
+}
+export interface ErrorHandlerConfig {
+    includeStack?: boolean;
+    logErrors?: boolean;
+    logStack?: boolean;
+    customHandlers?: Record<ErrorCode, (error: AppError) => any>;
+}
+export type ErorrHandler = (error: Error, req: IRequest, response: IResponse) => any;

package/dist/types/core/error.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorCode = void 0;
+var ErrorCode;
+(function (ErrorCode) {
+    ErrorCode["BAD_REQUEST"] = "BAD_REQUEST";
+    ErrorCode["UNAUTHORIZED"] = "UNAUTHORIZED";
+    ErrorCode["FORBIDDEN"] = "FORBIDDEN";
+    ErrorCode["NOT_FOUND"] = "NOT_FOUND";
+    ErrorCode["VALIDATION_FAILED"] = "VALIDATION_FAILED";
+    ErrorCode["RATE_LIMIT_EXCEEDED"] = "RATE_LIMIT_EXCEEDED";
+    ErrorCode["INTERNAL_ERROR"] = "INTERNAL_ERROR";
+    ErrorCode["SERVICE_UNAVAILABLE"] = "SERVICE_UNAVAILABLE";
+    ErrorCode["DATABASE_ERROR"] = "DATABASE_ERROR";
+    ErrorCode["DUPLICATE_ENTRY"] = "DUPLICATE_ENTRY";
+    ErrorCode["INVALID_STATE"] = "INVALID_STATE";
+    ErrorCode["DEPENDENCY_FAILED"] = "DEPENDENCY_FAILED";
+})(ErrorCode || (exports.ErrorCode = ErrorCode = {}));
+//# sourceMappingURL=error.js.map

package/dist/types/core/error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.js","sourceRoot":"","sources":["../../../src/types/core/error.ts"],"names":[],"mappings":";;;AAGA,IAAY,SAaX;AAbD,WAAY,SAAS;IACnB,wCAA2B,CAAA;IAC3B,0CAA6B,CAAA;IAC7B,oCAAuB,CAAA;IACvB,oCAAuB,CAAA;IACvB,oDAAuC,CAAA;IACvC,wDAA2C,CAAA;IAC3C,8CAAiC,CAAA;IACjC,wDAA2C,CAAA;IAC3C,8CAAiC,CAAA;IACjC,gDAAmC,CAAA;IACnC,4CAA+B,CAAA;IAC/B,oDAAuC,CAAA;AACzC,CAAC,EAbW,SAAS,yBAAT,SAAS,QAapB"}

package/dist/types/core/index.d.ts

@@ -0,0 +1,9 @@
+export * from './common';
+export * from './controller';
+export * from './cors';
+export * from './error';
+export * from './multipart';
+export * from './request';
+export * from './response';
+export * from './sanitize';
+export * from './sse';

package/dist/types/core/index.js

@@ -0,0 +1,26 @@
+"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("./common"), exports);
+__exportStar(require("./controller"), exports);
+__exportStar(require("./cors"), exports);
+__exportStar(require("./error"), exports);
+__exportStar(require("./multipart"), exports);
+__exportStar(require("./request"), exports);
+__exportStar(require("./response"), exports);
+__exportStar(require("./sanitize"), exports);
+__exportStar(require("./sse"), exports);
+//# sourceMappingURL=index.js.map

package/dist/types/core/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/types/core/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,2CAAyB;AACzB,+CAA6B;AAC7B,yCAAuB;AACvB,0CAAwB;AACxB,8CAA4B;AAC5B,4CAA0B;AAC1B,6CAA2B;AAC3B,6CAA2B;AAC3B,wCAAsB"}

package/dist/types/core/multipart.d.ts

@@ -0,0 +1,8 @@
+export interface MultipartFile {
+    fieldname: string;
+    filename: string;
+    contentType: string;
+    data: Buffer;
+    size: number;
+    encoding?: string;
+}

package/dist/types/core/multipart.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=multipart.js.map

package/dist/types/core/multipart.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"multipart.js","sourceRoot":"","sources":["../../../src/types/core/multipart.ts"],"names":[],"mappings":""}

package/dist/types/core/request.d.ts

@@ -0,0 +1,65 @@
+import { IncomingHttpHeaders } from 'http';
+export type RequestSource = 'http' | 'lambda' | 'unknown';
+export type EventType = 'apigateway' | 'apigatewayv2' | 'alb' | 'cloudfront' | 's3' | 'sns' | 'sqs' | 'dynamodb' | 'unknown';
+export interface RequestOptions {
+    method: string;
+    requestUrl: URL;
+    url: string;
+    path: string;
+    headers: Record<string, string | string[]>;
+    query: Record<string, string | string[]>;
+    body: any;
+    params: Record<string, string>;
+    cookies: Record<string, string>;
+    sourceIp?: string;
+    userAgent?: string;
+    requestId: string;
+    stage?: string;
+    timestamp: Date;
+    raw?: any;
+    context?: any;
+    rawBody?: any;
+    event?: unknown;
+    isBase64Encoded?: boolean;
+    source: RequestSource;
+}
+export interface IRequest {
+    method: string;
+    path: string;
+    url: string;
+    requestUrl: URL;
+    headers: Record<string, string | string[]>;
+    query: Record<string, string | string[]>;
+    body: any;
+    params: Record<string, string>;
+    cookies: Record<string, string>;
+    sourceIp: string;
+    userAgent: string;
+    requestId: string;
+    stage: string;
+    timestamp: Date;
+    source: RequestSource;
+    raw: any;
+    context: any;
+    rawBody: any;
+    isBase64Encoded: any;
+    startTime: number;
+    getHeader(name: string): string | string[] | undefined;
+    getCookie(name: string): string | undefined;
+    getQuery(name: string): string | string[] | undefined;
+    getParam(name: string): string | undefined;
+    isHttp(): boolean;
+    isLambda(): boolean;
+    getLambdaEvent(): unknown;
+    getLambdaContext(): unknown;
+    getHttpRequest(): IncomingHttpHeaders | undefined;
+    setState(key: string, value: any): void;
+    getState<T = any>(key: string): T | undefined;
+    getAllState(): Map<string, any>;
+    isSecure(): boolean;
+    getClientIp(): string;
+    getHost(): string;
+    getFullUrl(): string;
+    clone(overrides?: Partial<RequestOptions>): IRequest;
+    toJSON(): Record<string, any>;
+}

package/dist/types/core/request.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=request.js.map

package/dist/types/core/request.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"request.js","sourceRoot":"","sources":["../../../src/types/core/request.ts"],"names":[],"mappings":""}

package/dist/types/core/response.d.ts

@@ -0,0 +1,49 @@
+export type ResponseSource = 'http' | 'lambda' | 'unknown';
+export interface CookieOptions {
+    maxAge?: number;
+    expires?: Date;
+    path?: string;
+    domain?: string;
+    secure?: boolean;
+    httpOnly?: boolean;
+    sameSite?: 'strict' | 'lax' | 'none';
+    priority?: 'low' | 'medium' | 'high';
+    partitioned?: boolean;
+}
+export interface ResponseOptions {
+    statusCode?: number;
+    headers?: Record<string, string | string[]>;
+    body?: any;
+    cookies?: string[];
+    isBase64Encoded?: boolean;
+    encoding?: BufferEncoding;
+}
+export interface IResponse {
+    headers: Record<string, string | string[]>;
+    data: any;
+    cookies: string[];
+    isBase64Encoded: boolean;
+    source: ResponseSource;
+    raw: any;
+    headersSent: boolean;
+    ok: boolean;
+    meta: {
+        requestUrl: URL;
+        method: string;
+    };
+    status: number;
+    getStatus(): number;
+    setHeader(name: string, value: string | string[]): this;
+    getHeader(name: string): string | string[] | undefined;
+    hasHeader(name: string): boolean;
+    removeHeader(name: string): this;
+    setHeaders(headers: Record<string, string | string[]>): this;
+    setCookie(name: string, value: string, options?: CookieOptions): this;
+    clearCookie(name: string, options?: CookieOptions): this;
+    getCookies(): string[];
+    redirect(url: string, statusCode?: number): this;
+    end(data: unknown): this;
+    error(data: unknown): this;
+    reset(): this;
+    toJSON(): Record<string, any>;
+}

package/dist/types/core/response.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=response.js.map

package/dist/types/core/response.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"response.js","sourceRoot":"","sources":["../../../src/types/core/response.ts"],"names":[],"mappings":""}

package/dist/types/core/sanitize.d.ts

@@ -0,0 +1,8 @@
+import * as Joi from 'joi';
+export interface SanitizerConfig {
+    schema: Joi.Schema;
+    action?: 'validate' | 'sanitize' | 'both';
+    options?: Joi.ValidationOptions;
+    stripUnknown?: boolean;
+    type: 'headers' | 'body' | 'params' | 'query';
+}

package/dist/types/core/sanitize.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=sanitize.js.map

package/dist/types/core/sanitize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sanitize.js","sourceRoot":"","sources":["../../../src/types/core/sanitize.ts"],"names":[],"mappings":""}

package/dist/types/core/sse.d.ts

@@ -0,0 +1,37 @@
+import { ServerResponse } from 'http';
+export interface SSEClient {
+    id: string;
+    response: ServerResponse;
+    topics: Set<string>;
+    data: Record<string, any>;
+    connectedAt: Date;
+}
+export interface SSEMessage {
+    event?: string;
+    id?: string;
+    retry?: number;
+    data: any;
+}
+export interface SSEEvent {
+    type: 'connection' | 'close';
+    client: SSEClient;
+    data?: any;
+}
+export interface ISSEServer {
+    createConnection(res: ServerResponse): SSEClient;
+    sendToClient(clientId: string, message: SSEMessage): boolean;
+    broadcast(message: SSEMessage, excludeClientId?: string): void;
+    getStats(): {
+        clients: number;
+    };
+}
+export interface ISSEService {
+    initialize(sse: ISSEServer): void;
+    sendToClient(clientId: string, message: SSEMessage): boolean;
+    broadcast(message: SSEMessage, excludeClientId?: string): void;
+    getStats(): {
+        clients: number;
+    };
+    isAvailable(): boolean;
+    createConnection(res: ServerResponse): SSEClient;
+}

package/dist/types/core/sse.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=sse.js.map

package/dist/types/core/sse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sse.js","sourceRoot":"","sources":["../../../src/types/core/sse.ts"],"names":[],"mappings":""}

package/dist/types/ws/index.d.ts

@@ -0,0 +1,50 @@
+import WebSocket from 'ws';
+export type WebSocketHandlerType = 'connection' | 'message' | 'close' | 'error';
+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;
+    registerControllers(controllers: any[]): void;
+}

package/dist/types/ws/index.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=index.js.map

package/dist/types/ws/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/types/ws/index.ts"],"names":[],"mappings":""}

package/dist/utils/core/controller.d.ts

@@ -0,0 +1,25 @@
+import 'reflect-metadata';
+import { ControllerInstance, ControllerMethods, CORSConfig, InterceptorCB, IRequest, IResponse, MiddlewareCB, SanitizerConfig } from '../../types/core';
+export declare const executeControllerMethod: (controller: ControllerInstance, propertyName: string, request: IRequest, response: IResponse) => Promise<any>;
+export declare const getControllerMethods: (controller: ControllerInstance) => ControllerMethods;
+export declare const getAllMethods: (obj: any) => string[];
+export declare const findRouteInController: (instance: any, path: string, route: string, method: string) => {
+    name: string;
+    pathParams: Record<string, string>;
+    priority: number;
+    middlewares: MiddlewareCB[];
+    cors?: CORSConfig;
+    sanitizers: SanitizerConfig[];
+};
+export declare const NextFunction: (error: any) => void;
+export declare const getResponse: (data: {
+    controllerInstance: ControllerInstance;
+    name: string;
+    interceptors: InterceptorCB[];
+    request: IRequest;
+    response: IResponse;
+}) => Promise<any>;
+export declare const applyMiddlewaresVsSanitizers: (request: IRequest, response: IResponse, functions: {
+    sanitizers: SanitizerConfig[][];
+    middlewares: MiddlewareCB[][];
+}) => Promise<void>;