@heliosjs/http 1.0.1

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/http/http.d.ts

@@ -0,0 +1,111 @@
+import { PubSub } from 'type-graphql';
+import { InterceptorCB, MiddlewareCB } from '../core/common';
+import { ControllerClass, ControllerType } from '../core/controller';
+import { CORSConfig } from '../core/cors';
+import { AppError } from '../core/error';
+import { IRequest } from '../core/request';
+import { IResponse } from '../core/response';
+import { SanitizerConfig } from '../core/sanitize';
+import { Plugin } from './plugin';
+import { StaticConfig } from './static';
+export interface ServerConfig {
+    /**
+     * Port number the server listens on
+     * @type {number}
+     */
+    port?: number;
+    /**
+     * Hostname or IP address
+     * @type {string}
+     */
+    host?: string;
+    /**
+     * Array of middleware callback functions
+     * @type {MiddlewareCB[]}
+     */
+    middlewares?: MiddlewareCB[];
+    /**
+     * Interceptor callback function
+     * @type {InterceptorCB}
+     */
+    interceptor?: InterceptorCB;
+    /**
+     * Error handling callback
+     * @type {ErrorCB}
+     */
+    errorHandler?: (error: AppError, req: IRequest, response: IResponse) => any;
+    /**
+     * Array of controller types
+     * @type {ControllerType[]}
+     */
+    controllers?: ControllerType[];
+    /**
+     * CORS configuration object
+     * @type {CORSConfig}
+     */
+    cors?: CORSConfig;
+    /**
+     * Array of sanitizer configurations
+     * @type {SanitizerConfig[]}
+     */
+    sanitizers?: SanitizerConfig[];
+    /**
+     * Array of static file serving configurations
+     * @type {StaticConfig[]}
+     */
+    statics?: StaticConfig[];
+    /**
+     * WebSocket enablement and lazy loading
+     * @type {{ path: string; lazy?: boolean }}
+     */
+    websocket?: {
+        path: string;
+        lazy?: boolean;
+    };
+    /**
+     * Server-Sent Events enablement
+     * @type {{ enabled: boolean }}
+     */
+    sse?: {
+        enabled: boolean;
+    };
+    /**
+     * GraphQL configuration including playground, pubSub, and resolvers
+     * @type {{ playground?: boolean; pubSub?: PubSub; resolvers?: Function[] }}
+     */
+    graphql?: {
+        path: string;
+        playground?: boolean;
+        pubSub?: PubSub;
+        resolvers?: Function[];
+    };
+}
+import { Server } from 'http';
+export interface IHttpServer {
+    readonly app: Server;
+    plugins: Plugin[];
+    controllers: ControllerClass[];
+    /**
+     * Starts HTTP server
+     * @param port - port
+     * @param host - host
+     * @returns Promise with HTTP server instance
+     * @throws Error
+     */
+    listen(port?: number, host?: string): Promise<Server>;
+    /**
+     * Stops server
+     * @returns Promise
+     * @throws Error
+     */
+    close(): Promise<void>;
+    /**
+     * Get server status
+     * @returns object with server config
+     */
+    status(): {
+        running: boolean;
+        config: ServerConfig;
+    };
+    usePlugin(plugin: Plugin): IHttpServer;
+}

package/dist/types/http/http.js

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

package/dist/types/http/http.js.map

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

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

@@ -0,0 +1,3 @@
+export * from './http';
+export * from './plugin';
+export * from './static';

package/dist/types/http/index.js

@@ -0,0 +1,20 @@
+"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("./http"), exports);
+__exportStar(require("./plugin"), exports);
+__exportStar(require("./static"), exports);
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/types/http/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,yCAAuB;AACvB,2CAAyB;AACzB,2CAAyB"}

package/dist/types/http/plugin.d.ts

@@ -0,0 +1,18 @@
+import { IncomingMessage, Server } from 'http';
+import { IRequest, IResponse, MiddlewareCB } from '../core';
+import { IHttpServer } from './http';
+export interface HttpPluginHooks {
+    beforeRequest?: (req: IncomingMessage) => void | Promise<void>;
+    beforeRoute?: (req: IRequest, response: IResponse) => void | Promise<void>;
+    afterResponse?: (req: IRequest, res: IResponse) => void | Promise<void>;
+}
+export interface Plugin {
+    name: string;
+    onInit?(server: IHttpServer): void | Promise<void>;
+    onStart?(server: Server): void | Promise<void>;
+    onStop?(server: Server): void | Promise<void>;
+    middleware?: MiddlewareCB;
+    hooks?: HttpPluginHooks;
+}
+export type PluginHookKeys = keyof HttpPluginHooks;
+export type PluginKeys = keyof Omit<Plugin, 'name' | 'hooks'>;

package/dist/types/http/plugin.js

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

package/dist/types/http/plugin.js.map

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

package/dist/types/http/static.d.ts

@@ -0,0 +1,24 @@
+import fs from 'fs';
+import { ServerResponse } from 'http';
+export interface StaticOptions {
+    index?: string | boolean;
+    extensions?: string[];
+    maxAge?: number;
+    immutable?: boolean;
+    dotfiles?: 'allow' | 'deny' | 'ignore';
+    fallthrough?: boolean;
+    setHeaders?: (res: ServerResponse, path: string, stat: fs.Stats) => void;
+}
+export interface StaticConfig {
+    path: string;
+    options?: StaticOptions;
+}
+export interface StaticOptions {
+    index?: string | boolean;
+    extensions?: string[];
+    maxAge?: number;
+    immutable?: boolean;
+    dotfiles?: 'allow' | 'deny' | 'ignore';
+    fallthrough?: boolean;
+    setHeaders?: (res: ServerResponse, path: string, stat: fs.Stats) => void;
+}

package/dist/types/http/static.js

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

package/dist/types/http/static.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"static.js","sourceRoot":"","sources":["../../../src/types/http/static.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>;