@morojs/moro 1.7.30 → 1.8.1

package/dist/core/http/moro-engine-server.d.ts

@@ -0,0 +1,263 @@
+import { HttpRequest, HttpResponse, HttpHandler, Middleware } from '../../types/http.js';
+import { type EngineCapabilities } from '../utilities/package-utils.js';
+import type { HttpRuntimeLimits } from './utils/size.js';
+import type { Http2ServerOptions } from './http2-server.js';
+import { type CompressionSettings } from './utils/compression.js';
+import { LazyEventEmitter } from './utils/lazy-event-emitter.js';
+/**
+ * Prototype-based request object for the engine adapter.
+ *
+ * Headers/query/cookies/ip/requestId are lazy: a synchronous handler that
+ * never reads them pays nothing (no native crossing, no UUID). Every fetcher
+ * returns a stable snapshot and reqIds are safe no-ops after the response
+ * terminates, so - unlike the uWS adapter - there is no validity window.
+ */
+export declare class EngineRequest extends LazyEventEmitter {
+    method: string;
+    path: string;
+    params: Record<string, string>;
+    body: any;
+    _server: MoroEngineServer;
+    _reqId: number;
+    _url: string | undefined;
+    _queryString: string | undefined;
+    _query: Record<string, string> | undefined;
+    _headers: Record<string, string> | undefined;
+    _cookies: Record<string, string> | undefined;
+    _context: Record<string, any> | undefined;
+    _requestId: string | undefined;
+    _ip: string | undefined;
+    _socket: any;
+    constructor(server: MoroEngineServer, reqId: number, method: string, path: string);
+    /** Engine snapshots are stable - nothing to detach. No-op kept for
+     *  interface parity with UwsRequest so shared dispatch code can call it. */
+    materialize(): void;
+    private _rawQueryString;
+    get url(): string;
+    set url(value: string);
+    get query(): Record<string, string>;
+    set query(value: Record<string, string>);
+    get headers(): Record<string, string>;
+    set headers(value: Record<string, string>);
+    get cookies(): Record<string, string>;
+    set cookies(value: Record<string, string>);
+    get context(): Record<string, any>;
+    set context(value: Record<string, any>);
+    get requestId(): string;
+    set requestId(value: string);
+    get ip(): string;
+    set ip(value: string);
+    get socket(): any;
+    set socket(value: any);
+    get connection(): any;
+    set connection(value: any);
+    get hostname(): string;
+    get protocol(): string;
+    get secure(): boolean;
+    get xhr(): boolean;
+    get originalUrl(): string;
+    get ips(): string[];
+    get subdomains(): string[];
+    get(name: string): string | undefined;
+    header(name: string): string | undefined;
+    is(type: string): boolean;
+    accepts(types?: string | string[]): string | false;
+    acceptsLanguages(langs?: string | string[]): string | false;
+}
+/**
+ * Prototype-based response object for the engine adapter. Same
+ * MoroResponseMethods surface as the uWS adapter's ResponsePrototype.
+ *
+ * Terminal writes (json/send/end/redirect) go out as ONE respond() call -
+ * status + headers + body in a single native crossing. Streaming responses
+ * (writeHead/write/end) map to the engine's streaming API; the engine's
+ * onWritable backpressure signal surfaces as the 'drain' event.
+ */
+export declare class EngineResponse extends LazyEventEmitter {
+    headersSent: boolean;
+    statusCode: number;
+    responseHeaders: Record<string, string | string[]>;
+    locals: Record<string, any>;
+    _moroReq: any;
+    private _server;
+    private _engine;
+    private _reqId;
+    private _logger;
+    private _ended;
+    private _aborted;
+    constructor(server: MoroEngineServer, reqId: number, logger: any);
+    get writableEnded(): boolean;
+    get writableFinished(): boolean;
+    get finished(): boolean;
+    get aborted(): boolean;
+    private _emitDone;
+    _handleAbort(): void;
+    _handleWritable(): void;
+    private _headersFlat;
+    status(code: number): this;
+    setHeader(name: string, value: string | string[]): this;
+    getHeader(name: string): string | string[] | undefined;
+    removeHeader(name: string): this;
+    json(data: any): void;
+    private _respondMaybeCompressed;
+    private _failSafe;
+    send(data: string | Buffer): void;
+    writeHead(statusCode: number, reasonOrHeaders?: any, maybeHeaders?: any): this;
+    write(chunk: any, encoding?: any, callback?: any): boolean;
+    end(data?: any, encoding?: any, callback?: any): this;
+    redirect(url: string, code?: number): void;
+    success<T = any>(data: T, message?: string): void;
+    error(error: string, code?: string, message?: string): void;
+    unauthorized(message?: string): void;
+    forbidden(message?: string): void;
+    notFound(resource?: string): void;
+    badRequest(message?: string): void;
+    conflict(message: string): void;
+    internalError(message?: string): void;
+    validationError(errors: Array<{
+        field: string;
+        message: string;
+        code?: string;
+    }>): void;
+    rateLimited(retryAfter?: number): void;
+    created<T = any>(data: T, location?: string): void;
+    noContent(): void;
+    paginated<T = any>(data: T[], pagination: {
+        page: number;
+        limit: number;
+        total: number;
+    }): void;
+    cookie(name: string, value: string, options?: any): this;
+    clearCookie(name: string, options?: any): this;
+    sendFile(filePath: string): Promise<void>;
+    attachment(filename?: string): this;
+    download(filePath: string, filename?: string): Promise<void>;
+    format(handlers: Record<string, () => any | Promise<any>>): void;
+    set(field: string | Record<string, any>, value?: any): this;
+    get(field: string): string | string[] | undefined;
+    hasHeader(name: string): boolean;
+    setBulkHeaders(headers: Record<string, string | number>): this;
+    appendHeader(name: string, value: string | string[]): this;
+    append(field: string, value: string | string[]): this;
+    type(contentType: string): this;
+    sendStatus(code: number): void;
+    location(url: string): this;
+    vary(field: string | string[]): this;
+    links(links: Record<string, string>): this;
+    canSetHeaders(): boolean;
+    getResponseState(): {
+        headersSent: boolean;
+        statusCode: number;
+        headers: Record<string, string | string[]>;
+        finished: boolean;
+        writable: boolean;
+    };
+}
+/**
+ * Moro Engine HTTP Server Adapter
+ * Bridges @morojs/engine with Moro's HTTP abstractions. Duck-typed to the
+ * same surface framework.ts/moro.ts use on UWebSocketsHttpServer.
+ */
+export declare class MoroEngineServer {
+    /** @internal read by EngineRequest/EngineResponse for lazy fetchers */
+    _engine: any;
+    /** @internal read by EngineRequest#protocol/socket.encrypted - true when the
+     *  engine is terminating TLS for this server (engine >= 1.2.0 + ssl passed) */
+    isSsl: boolean;
+    private serverId;
+    private globalMiddleware;
+    private logger;
+    private hookManager;
+    private requestCounter;
+    private requestTrackingEnabled;
+    private isListening;
+    private port?;
+    private host?;
+    private inflight;
+    private handle;
+    private _wsBridge?;
+    private _pendingWsInfo?;
+    private maxBodySize;
+    private maxUploadSize;
+    private reusePort;
+    private _capabilities?;
+    private _limits?;
+    private _ssl?;
+    private _http2Settings?;
+    private multipartLimits?;
+    /** @internal read by EngineResponse for buffered-response compression */
+    _compression: CompressionSettings;
+    private closed;
+    private routerHandler?;
+    private errorHandler?;
+    private directRoutes;
+    constructor(options?: {
+        /** Normalized SSL config projected for the engine (both shapes). */
+        ssl?: Record<string, any> | null;
+        /** Engine feature flags (from loadNativeEngine) - gates the ssl/http2/
+         *  limit options so we never pass a key an older engine won't parse. */
+        capabilities?: EngineCapabilities;
+        /** Flattened runtime limits (bytes/ms) from the framework. */
+        limits?: HttpRuntimeLimits;
+        /** HTTP/2 settings when serving ALPN h2 natively (engine caps.http2). */
+        http2Settings?: Http2ServerOptions;
+        maxBodySize?: number;
+        maxUploadSize?: number;
+        /** Preloaded native engine module (from loadNativeEngine) - avoids a
+         * second resolution and keeps load failures at the framework's
+         * synchronous preflight instead of surfacing at listen() */
+        engineModule?: any;
+        /** Bind with SO_REUSEPORT so cluster workers can share the port
+         * (POSIX only; the framework gates Windows clustering to Node) */
+        reusePort?: boolean;
+    });
+    /** @internal terminal write/abort cleanup - drops the reqId mapping */
+    _complete(reqId: number): void;
+    private registerWithEngine;
+    /** Register the engine WebSocket bridge; upgrade requests then route natively. */
+    enableWebSocket(bridge: {
+        onOpen(wsId: number, path: string): void;
+        onMessage(wsId: number, data: any, isBinary: boolean): void;
+        onClose(wsId: number, code: number): void;
+    }): void;
+    /** Send a frame on a WebSocket. Returns false on backpressure. */
+    wsSend(wsId: number, data: string | ArrayBuffer | Buffer, isBinary: boolean): boolean;
+    /** Close a WebSocket (RFC 6455 close frame). */
+    wsClose(wsId: number, code?: number, reason?: string): void;
+    setRouterHandler(fn: (req: HttpRequest, res: HttpResponse) => boolean | Promise<boolean>): void;
+    setErrorHandler(fn: (err: any, req: HttpRequest, res: HttpResponse) => any | Promise<any>): void;
+    private requestDecorationKeys;
+    private requestDecorations;
+    private responseDecorationKeys;
+    private responseDecorations;
+    setRequestDecorations(decorations: Record<string, any>): void;
+    setResponseDecorations(decorations: Record<string, any>): void;
+    private addDirectRoute;
+    get(path: string, ...handlers: Array<Middleware | HttpHandler>): void;
+    post(path: string, ...handlers: Array<Middleware | HttpHandler>): void;
+    put(path: string, ...handlers: Array<Middleware | HttpHandler>): void;
+    delete(path: string, ...handlers: Array<Middleware | HttpHandler>): void;
+    patch(path: string, ...handlers: Array<Middleware | HttpHandler>): void;
+    options(path: string, ...handlers: Array<Middleware | HttpHandler>): void;
+    head(path: string, ...handlers: Array<Middleware | HttpHandler>): void;
+    private dispatchDirectRoute;
+    setNativeRouteProvider(_provider: () => Array<any>, _onError?: (...args: any[]) => any): void;
+    private onRequest;
+    private onAborted;
+    private onWritable;
+    private handleRequest;
+    private parseBody;
+    private executeMiddleware;
+    use(middleware: Middleware): void;
+    setRequestTracking(enabled: boolean): void;
+    setHookManager(hookManager: any): void;
+    configurePerformance(config: any): void;
+    listen(port: number, callback?: () => void): void;
+    listen(port: number, host: string, callback?: () => void): void;
+    /** Bounded drain window for in-flight responses during close() */
+    private static readonly CLOSE_DRAIN_MS;
+    close(callback?: (error?: Error) => void): void;
+    getServer(): any;
+    getApp(): any;
+    forceCleanup(): void;
+}