lacis/dist/index-pGWdfH82.d.ts

Zero-dependency TypeScript web framework

import { IncomingMessage, ServerResponse } from 'http';

interface CookieOptions {
    path?: string;
    domain?: string;
    maxAge?: number;
    expires?: Date;
    httpOnly?: boolean;
    secure?: boolean;
    sameSite?: 'Strict' | 'Lax' | 'None';
}
interface RequestCookies {
    get(name: string): string | undefined;
    all(): Record<string, string>;
}
interface ResponseCookies {
    set(name: string, value: string, options?: CookieOptions): ResponseCookies;
    delete(name: string, options?: Pick<CookieOptions, 'path' | 'domain'>): ResponseCookies;
}
interface UploadedFile {
    filename: string;
    mimetype: string;
    data: Buffer;
    size: number;
}
interface Request extends IncomingMessage {
    params?: Record<string, string>;
    query?: Record<string, string>;
    cookies: RequestCookies;
    getHeader(name: string): string | undefined;
    createSSEClient(options?: SSEClientOptions, handlers?: SSEEventHandlers): SSEClient;
    json<T>(): Promise<T>;
    form<T>(): Promise<T>;
    body(): Promise<Buffer>;
}
interface Response extends ServerResponse {
    headers?: Record<string, string>;
    body?: any;
    cookies: ResponseCookies;
    json(data: any): void;
    html(data: string): void;
    redirect(url: string, status?: number): void;
    send(data: any): void;
    status(code: number): Response;
    initSSE(options?: SSEOptions): SSEContext;
}

type MiddlewareType = 'beforeRequest' | 'afterRequest' | 'onError';
type MiddlewareCallback = (req: Request, res: Response, context?: any) => Promise<void | boolean> | void | boolean;
type NotFoundHook = (req: Request, res: Response) => void | Promise<void>;
type ShutdownHook = () => void | Promise<void>;
interface MiddlewareModule {
    beforeRequest?: MiddlewareCallback[];
    afterRequest?: MiddlewareCallback[];
    onError?: MiddlewareCallback[];
}
type PathMiddlewares = Map<string, {
    beforeRequest: MiddlewareCallback[];
    afterRequest: MiddlewareCallback[];
    onError: MiddlewareCallback[];
}>;

interface ServerlessMiddleware {
    path: string;
    type: 'cascade' | 'exact';
    module: {
        beforeRequest?: MiddlewareCallback | MiddlewareCallback[];
        afterRequest?: MiddlewareCallback | MiddlewareCallback[];
        onError?: MiddlewareCallback | MiddlewareCallback[];
    };
}
interface AdapterRequest extends IncomingMessage {
    params?: Record<string, string>;
    query?: Record<string, string>;
    body?(): Promise<Buffer>;
    createSSEClient(options?: SSEClientOptions, handlers?: SSEEventHandlers): SSEClient;
}
interface AdapterResponse {
    json?: (data: any) => void;
}
interface AdapterContext {
    req: AdapterRequest;
    res: AdapterResponse;
    route?: Route;
}
interface ServerlessRoute {
    path: string;
    handlers: RouteHandlers;
}
interface ServerlessConfig {
    routes: ServerlessRoute[];
    cors?: CorsConfig;
    middleware?: {
        beforeRequest?: MiddlewareCallback | MiddlewareCallback[];
        afterRequest?: MiddlewareCallback | MiddlewareCallback[];
        onError?: MiddlewareCallback | MiddlewareCallback[];
    };
    middlewares?: ServerlessMiddleware[];
    hooks?: {
        onNotFound?: NotFoundHook;
        onShutdown?: ShutdownHook;
    };
}
interface Adapter {
    name: string;
    createHandler: (config: string | ServerlessConfig) => unknown;
}

interface SSEContext {
    send(data: string): boolean;
    json(data: any): boolean;
    event(event: string, data: any): boolean;
    comment(text: string): boolean;
    id(id: string): boolean;
    retry(ms: number): boolean;
    close(comment?: string): void;
    error(event: string, message: string, code?: number, details?: string): void;
}
interface SSEOptions {
    headers?: Record<string, string>;
    timeout?: number;
}
interface SSEClientOptions {
    reconnectInterval?: number;
    maxRetries?: number;
    body?: string | Record<string, any>;
    contentType?: string;
    method?: "GET" | "POST" | "PUT";
    params?: string | Record<string, string>;
    disableReconnect?: boolean;
}
interface SSEEventHandlers {
    onMessage?: (data: any) => void;
    onEvent?: Record<string, (data: any) => void>;
    onClose?: () => void;
    onError?: (error: Error) => void;
}
interface SSEClient {
    onMessage: (callback: (data: any) => void) => SSEClient;
    onEvent: (eventName: string, callback: (data: any) => void) => SSEClient;
    onClose: (callback: () => void) => SSEClient;
    close: () => void;
}

interface CorsConfig {
    origin?: string | string[] | RegExp | ((origin: string) => boolean);
    methods?: string[];
    allowedHeaders?: string[];
    exposedHeaders?: string[];
    credentials?: boolean;
    maxAge?: number;
}
type Handler = (req: Request, res: Response) => Promise<void>;
type RouteHandlers = {
    GET?: Handler;
    POST?: Handler;
    PUT?: Handler;
    DELETE?: Handler;
    PATCH?: Handler;
};
type Route = {
    pattern: RegExp;
    handlers: RouteHandlers;
    params: string[];
};
interface ServerConfig {
    isDev?: boolean;
    port?: number;
    platform?: 'node' | 'vercel' | 'netlify' | 'bun';
    timeout?: number;
    httpsOptions?: {
        cert?: string | Buffer;
        key?: string | Buffer;
        ca?: string | Buffer | Array<string | Buffer>;
    };
    cluster?: {
        enabled: boolean;
        workers?: number;
    };
    defaultHeaders?: Record<string, string>;
    cors?: CorsConfig;
    middleware?: {
        beforeRequest?: MiddlewareCallback | MiddlewareCallback[];
        afterRequest?: MiddlewareCallback | MiddlewareCallback[];
        onError?: MiddlewareCallback | MiddlewareCallback[];
    };
    hooks?: {
        onNotFound?: NotFoundHook;
        onShutdown?: ShutdownHook;
    };
    routes?: ServerlessRoute[];
    openapi?: {
        path?: string;
        info: {
            title: string;
            version: string;
            description?: string;
        };
    };
    monitoring?: {
        enabled: boolean;
        sampleInterval?: number;
        reportInterval?: number;
        thresholds?: {
            cpu?: number;
            memory?: number;
            responseTime?: number;
            errorRate?: number;
        };
    };
}
interface ClusterConfig {
    enabled: boolean;
    workers?: number;
}

export type { AdapterRequest as A, CorsConfig as C, Handler as H, MiddlewareType as M, NotFoundHook as N, PathMiddlewares as P, Request as R, ServerConfig as S, UploadedFile as U, AdapterResponse as a, Response as b, ServerlessRoute as c, MiddlewareCallback as d, ShutdownHook as e, ServerlessMiddleware as f, SSEOptions as g, SSEClientOptions as h, SSEEventHandlers as i, SSEClient as j, Adapter as k, AdapterContext as l, ClusterConfig as m, CookieOptions as n, MiddlewareModule as o, RequestCookies as p, ResponseCookies as q, Route as r, RouteHandlers as s, SSEContext as t, ServerlessConfig as u };