@deepkit/framework/dist/cjs/src/worker.d.ts

import { RpcKernel, RpcKernelBaseConnection, TransportConnection } from '@deepkit/rpc';
import http, { Server } from 'http';
import https from 'https';
import { HttpConfig, HttpKernel, HttpRequest, HttpResponse } from '@deepkit/http';
import { InjectorContext } from '@deepkit/injector';
import { RpcControllers } from './rpc.js';
import { SecureContextOptions, TlsOptions } from 'tls';
import { LoggerInterface } from '@deepkit/logger';
export interface WebServerOptions {
    host: string;
    /**
     * Defines the port of the http server.
     * If ssl is defined, this port is used for the https server. If you want to have http and https
     * at the same time, use `httpsPort` accordingly.
     */
    port: number;
    varPath: string;
    compression: number;
    /**
     * If httpsPort and ssl is defined, then the https server is started additional to the http-server.
     *
     * In a production deployment, you usually want both, http and https server.
     * Set `port: 80` and `httpsPort: 443` to have both.
     */
    httpsPort?: number;
    http: HttpConfig;
    /**
     * When external server should be used. If this is set, all other options are ignored.
     */
    server?: Server;
    /**
     * When server is shutting down gracefully, this timeout is used to wait for all connections to be closed.
     */
    gracefulShutdownTimeout: number;
    /**
     * Enables HTTPS.
     * Make sure to pass `sslKey` and `sslCertificate` as well (or use sslOptions).
     */
    ssl: boolean;
    sslKey?: string;
    sslCertificate?: string;
    sslCa?: string;
    sslCrl?: string;
    /**
     * If defined https.createServer is used and all options passed as is to it.
     * Make sure to pass `key` and `cert`, as described in Node's https.createServer() documentation.
     * See https://nodejs.org/api/https.html#https_https_createserver_options_requestlistener
     */
    sslOptions?: SecureContextOptions & TlsOptions;
    /**
     * When true keys & certificates are created on-the-fly (for development purposes).
     * Should not be used in production.
     */
    selfSigned?: boolean;
}
export interface RpcServerListener {
    close(): void | Promise<void>;
}
export interface RpcServerCreateConnection {
    (transport: TransportConnection, request?: HttpRequest): RpcKernelBaseConnection;
}
export interface RpcServerOptions {
    server?: http.Server | https.Server;
}
export interface RpcServerInterface {
    start(options: RpcServerOptions, createRpcConnection: RpcServerCreateConnection): void;
}
export declare class RpcServer implements RpcServerInterface {
    start(options: RpcServerOptions, createRpcConnection: RpcServerCreateConnection): RpcServerListener;
}
export declare class WebWorkerFactory {
    protected httpKernel: HttpKernel;
    logger: LoggerInterface;
    protected rpcControllers: RpcControllers;
    protected injectorContext: InjectorContext;
    protected rpcServer: RpcServer;
    protected rpcKernel: RpcKernel;
    constructor(httpKernel: HttpKernel, logger: LoggerInterface, rpcControllers: RpcControllers, injectorContext: InjectorContext, rpcServer: RpcServer, rpcKernel: RpcKernel);
    create(id: number, options: WebServerOptions): WebWorker;
}
export declare class WebMemoryWorkerFactory extends WebWorkerFactory {
    create(id: number, options: WebServerOptions): WebMemoryWorker;
}
export declare function createRpcConnection(rootScopedContext: InjectorContext, rpcKernel: RpcKernel, transport: TransportConnection, request?: HttpRequest): RpcKernelBaseConnection;
export declare class WebWorker {
    readonly id: number;
    logger: LoggerInterface;
    httpKernel: HttpKernel;
    rpcKernel: RpcKernel;
    protected injectorContext: InjectorContext;
    protected options: WebServerOptions;
    private rpcServer;
    protected rpcListener?: RpcServerListener;
    protected server?: http.Server | https.Server;
    protected servers?: https.Server;
    protected shuttingDown: boolean;
    protected activeRequests: number;
    protected compressionOptions: {
        level: number;
        chunkSize: number;
        memLevel: number;
        strategy: number;
        windowBits: number;
    };
    constructor(id: number, logger: LoggerInterface, httpKernel: HttpKernel, rpcKernel: RpcKernel, injectorContext: InjectorContext, options: WebServerOptions, rpcServer: RpcServer);
    handleRequest(request: HttpRequest, response: HttpResponse): Promise<void> | undefined;
    applyServerSettings(server: Server): void;
    start(): void;
    private startRpc;
    close(graceful?: boolean): Promise<void>;
}
export declare class WebMemoryWorker extends WebWorker {
    start(): void;
}
export declare type __ΩWebServerOptions = any[];
export declare type __ΩRpcServerListener = any[];
export declare type __ΩRpcServerCreateConnection = any[];
export declare type __ΩRpcServerOptions = any[];
export declare type __ΩRpcServerInterface = any[];