@venok/http 1.0.1-canary.0

package/adapter/adapter.d.ts

@@ -0,0 +1,57 @@
+import { RequestMethod } from "@venok/http/enums";
+import { CorsOptions, CorsOptionsDelegate, HttpServer, RequestHandler, VenokApplicationOptions, VersioningOptions, VersionValue } from "@venok/http/interfaces";
+/**
+ * @publicApi
+ */
+export declare abstract class AbstractHttpAdapter<TServer = any, TRequest = any, TResponse = any> implements HttpServer<TRequest, TResponse> {
+    protected instance?: any;
+    protected httpServer: TServer;
+    constructor(instance?: any);
+    init(): Promise<void>;
+    use(...args: any[]): any;
+    get(handler: RequestHandler): any;
+    get(path: any, handler: RequestHandler): any;
+    post(handler: RequestHandler): any;
+    post(path: any, handler: RequestHandler): any;
+    head(handler: RequestHandler): any;
+    head(path: any, handler: RequestHandler): any;
+    delete(handler: RequestHandler): any;
+    delete(path: any, handler: RequestHandler): any;
+    put(handler: RequestHandler): any;
+    put(path: any, handler: RequestHandler): any;
+    patch(handler: RequestHandler): any;
+    patch(path: any, handler: RequestHandler): any;
+    all(handler: RequestHandler): any;
+    all(path: any, handler: RequestHandler): any;
+    search(port: string | number, callback?: () => void): any;
+    search(port: string | number, hostname: string, callback?: () => void): any;
+    options(handler: RequestHandler): any;
+    options(path: any, handler: RequestHandler): any;
+    listen(port: string | number, callback?: () => void): void;
+    listen(port: string | number, hostname: string, callback?: () => void): void;
+    getHttpServer(): TServer;
+    setHttpServer(httpServer: TServer): void;
+    setInstance<T = any>(instance: T): void;
+    getInstance<T = any>(): T;
+    abstract close(): this | Promise<this>;
+    abstract initHttpServer(options: VenokApplicationOptions): this;
+    abstract useStaticAssets(...args: any[]): this;
+    abstract setViewEngine(engine: string): this;
+    abstract getRequestHostname(request: any): any;
+    abstract getRequestMethod(request: any): any;
+    abstract getRequestUrl(request: any): any;
+    abstract status(response: any, statusCode: number): any;
+    abstract reply(response: any, body: any, statusCode?: number): any;
+    abstract end(response: any, message?: string): any;
+    abstract render(response: any, view: string, options: any): any;
+    abstract redirect(response: any, statusCode: number, url: string): any;
+    abstract setErrorHandler(handler: Function, prefix?: string): any;
+    abstract setNotFoundHandler(handler: Function, prefix?: string): any;
+    abstract isHeadersSent(response: any): any;
+    abstract setHeader(response: any, name: string, value: string): any;
+    abstract registerParserMiddleware(prefix?: string, rawBody?: boolean): any;
+    abstract enableCors(options: CorsOptions | CorsOptionsDelegate<TRequest>, prefix?: string): any;
+    abstract createMiddlewareFactory(requestMethod: RequestMethod): ((path: string, callback: Function) => any) | Promise<(path: string, callback: Function) => any>;
+    abstract getType(): string;
+    abstract applyVersionFilter(handler: Function, version: VersionValue, versioningOptions: VersioningOptions): (req: TRequest, res: TResponse, next: () => void) => Function;
+}

package/adapter/adapter.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractHttpAdapter = void 0;
+/**
+ * @publicApi
+ */
+class AbstractHttpAdapter {
+    constructor(instance) {
+        this.instance = instance;
+    }
+    async init() { }
+    use(...args) {
+        return this.instance.use(...args);
+    }
+    get(...args) {
+        return this.instance.get(...args);
+    }
+    post(...args) {
+        return this.instance.post(...args);
+    }
+    head(...args) {
+        return this.instance.head(...args);
+    }
+    delete(...args) {
+        return this.instance.delete(...args);
+    }
+    put(...args) {
+        return this.instance.put(...args);
+    }
+    patch(...args) {
+        return this.instance.patch(...args);
+    }
+    all(...args) {
+        return this.instance.all(...args);
+    }
+    search(port, hostname, callback) {
+        return this.instance.search(port, hostname, callback);
+    }
+    options(...args) {
+        return this.instance.options(...args);
+    }
+    listen(port, hostname, callback) {
+        return this.instance.listen(port, hostname, callback);
+    }
+    getHttpServer() {
+        return this.httpServer;
+    }
+    setHttpServer(httpServer) {
+        this.httpServer = httpServer;
+    }
+    setInstance(instance) {
+        this.instance = instance;
+    }
+    getInstance() {
+        return this.instance;
+    }
+}
+exports.AbstractHttpAdapter = AbstractHttpAdapter;

package/adapter/host.d.ts

@@ -0,0 +1,27 @@
+import { AbstractHttpAdapter } from "@venok/http/adapter/adapter";
+/**
+ * Defines the `HttpAdapterHost` object.
+ *
+ * `HttpAdapterHost` wraps the underlying
+ * platform-specific `HttpAdapter`.  The `HttpAdapter` is a wrapper around the underlying
+ * native HTTP server library (e.g., Express).  The `HttpAdapterHost` object
+ * provides methods to `get` and `set` the underlying HttpAdapter.
+ *
+ * @publicApi
+ */
+export declare class HttpAdapterHost<T extends AbstractHttpAdapter = AbstractHttpAdapter> {
+    private _httpAdapter?;
+    /**
+     * Accessor for the underlying `HttpAdapter`
+     *
+     * @param httpAdapter reference to the `HttpAdapter` to be set
+     */
+    set httpAdapter(httpAdapter: T);
+    /**
+     * Accessor for the underlying `HttpAdapter`
+     *
+     * @example
+     * `const httpAdapter = adapterHost.httpAdapter;`
+     */
+    get httpAdapter(): T;
+}

package/adapter/host.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpAdapterHost = void 0;
+/**
+ * Defines the `HttpAdapterHost` object.
+ *
+ * `HttpAdapterHost` wraps the underlying
+ * platform-specific `HttpAdapter`.  The `HttpAdapter` is a wrapper around the underlying
+ * native HTTP server library (e.g., Express).  The `HttpAdapterHost` object
+ * provides methods to `get` and `set` the underlying HttpAdapter.
+ *
+ * @publicApi
+ */
+class HttpAdapterHost {
+    /**
+     * Accessor for the underlying `HttpAdapter`
+     *
+     * @param httpAdapter reference to the `HttpAdapter` to be set
+     */
+    set httpAdapter(httpAdapter) {
+        this._httpAdapter = httpAdapter;
+    }
+    /**
+     * Accessor for the underlying `HttpAdapter`
+     *
+     * @example
+     * `const httpAdapter = adapterHost.httpAdapter;`
+     */
+    get httpAdapter() {
+        return this._httpAdapter;
+    }
+}
+exports.HttpAdapterHost = HttpAdapterHost;

package/application/application.d.ts

@@ -0,0 +1,18 @@
+import { CorsOptions, CorsOptionsDelegate, GlobalPrefixOptions, HttpServer, VersioningOptions } from "../interfaces";
+import { HttpConfig } from "./config";
+import { AbstractHttpAdapter } from "../adapter/adapter";
+export declare class HttpApplication {
+    private readonly httpAdapter;
+    private readonly config;
+    private start;
+    constructor(httpAdapter: HttpServer, config: HttpConfig);
+    use(...args: [any, any?]): this;
+    getHttpAdapter(): AbstractHttpAdapter;
+    enableCors(options?: CorsOptions | CorsOptionsDelegate<any>): this;
+    enableVersioning(options?: VersioningOptions): this;
+    setGlobalPrefix(prefix: string, options?: GlobalPrefixOptions): this;
+    useStaticAssets(options: any): this;
+    useStaticAssets(path: string, options?: any): this;
+    setBaseViewsDir(path: string | string[]): this;
+    setViewEngine(engineOrOptions: any): this;
+}

package/application/application.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpApplication = void 0;
+const enums_1 = require("../enums");
+const utils_1 = require("../middleware/utils");
+class HttpApplication {
+    constructor(httpAdapter, config) {
+        this.httpAdapter = httpAdapter;
+        this.config = config;
+        this.start = false;
+    }
+    use(...args) {
+        this.httpAdapter.use(...args);
+        return this;
+    }
+    getHttpAdapter() {
+        return this.httpAdapter;
+    }
+    enableCors(options) {
+        this.httpAdapter.enableCors(options);
+        return this;
+    }
+    enableVersioning(options = { type: enums_1.VersioningType.URI }) {
+        this.config.enableVersioning(options);
+        return this;
+    }
+    setGlobalPrefix(prefix, options) {
+        this.config.setGlobalPrefix(prefix);
+        if (options) {
+            const exclude = options?.exclude ? (0, utils_1.mapToExcludeRoute)(options.exclude) : [];
+            this.config.setGlobalPrefixOptions({
+                ...options,
+                exclude,
+            });
+        }
+        return this;
+    }
+    useStaticAssets(pathOrOptions, options) {
+        this.httpAdapter.useStaticAssets && this.httpAdapter.useStaticAssets(pathOrOptions, options);
+        return this;
+    }
+    setBaseViewsDir(path) {
+        this.httpAdapter.setBaseViewsDir && this.httpAdapter.setBaseViewsDir(path);
+        return this;
+    }
+    setViewEngine(engineOrOptions) {
+        this.httpAdapter.setViewEngine && this.httpAdapter.setViewEngine(engineOrOptions);
+        return this;
+    }
+}
+exports.HttpApplication = HttpApplication;

package/application/config.d.ts

@@ -0,0 +1,16 @@
+import { ExcludeRouteMetadata, GlobalPrefixOptions, VersioningOptions } from "../interfaces";
+export declare class HttpConfig {
+    private globalPrefix;
+    private globalPrefixOptions;
+    private versioningOptions;
+    private readonly httpInstanceStorage;
+    setHttpAdapter(httpAdapter: any): void;
+    getHttpAdapterRef(): import("../adapter/adapter").AbstractHttpAdapter<any, any, any>;
+    getHttpAdapterHostRef(): import("../adapter/host").HttpAdapterHost<import("../adapter/adapter").AbstractHttpAdapter<any, any, any>>;
+    setGlobalPrefix(prefix: string): void;
+    getGlobalPrefix(): string;
+    setGlobalPrefixOptions(options: GlobalPrefixOptions<ExcludeRouteMetadata>): void;
+    getGlobalPrefixOptions(): GlobalPrefixOptions<ExcludeRouteMetadata>;
+    enableVersioning(options: VersioningOptions): void;
+    getVersioning(): VersioningOptions | undefined;
+}

package/application/config.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpConfig = void 0;
+const http_instance_storage_1 = require("../storage/http-instance.storage");
+class HttpConfig {
+    constructor() {
+        this.globalPrefix = "";
+        this.globalPrefixOptions = {};
+        this.httpInstanceStorage = new http_instance_storage_1.HttpInstanceStorage();
+    }
+    setHttpAdapter(httpAdapter) {
+        this.httpInstanceStorage.httpAdapter = httpAdapter;
+        if (!this.httpInstanceStorage.httpAdapterHost)
+            return;
+        const host = this.httpInstanceStorage.httpAdapterHost;
+        host.httpAdapter = httpAdapter;
+    }
+    getHttpAdapterRef() {
+        return this.httpInstanceStorage.httpAdapter;
+    }
+    getHttpAdapterHostRef() {
+        return this.httpInstanceStorage.httpAdapterHost;
+    }
+    setGlobalPrefix(prefix) {
+        this.globalPrefix = prefix;
+    }
+    getGlobalPrefix() {
+        return this.globalPrefix;
+    }
+    setGlobalPrefixOptions(options) {
+        this.globalPrefixOptions = options;
+    }
+    getGlobalPrefixOptions() {
+        return this.globalPrefixOptions;
+    }
+    enableVersioning(options) {
+        if (Array.isArray(options.defaultVersion)) {
+            // Drop duplicated versions
+            options.defaultVersion = Array.from(new Set(options.defaultVersion));
+        }
+        this.versioningOptions = options;
+    }
+    getVersioning() {
+        return this.versioningOptions;
+    }
+}
+exports.HttpConfig = HttpConfig;

package/application/http.module-defenition.d.ts

@@ -0,0 +1,8 @@
+import { HttpApplication } from "./application";
+import { AbstractHttpAdapter } from "../adapter/adapter";
+export interface HttpAppOptions {
+    port: number;
+    callback?: (app: HttpApplication) => void;
+    adapter?: AbstractHttpAdapter;
+}
+export declare const HttpConfigurableModuleClass: import("@venok/core/module").ConfigurableModuleCls<HttpAppOptions, "register", "create", {}>, HTTP_APP_OPTIONS: string | symbol;

package/application/http.module-defenition.js

@@ -0,0 +1,6 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HTTP_APP_OPTIONS = exports.HttpConfigurableModuleClass = void 0;
+const module_1 = require("../../core/module");
+_a = new module_1.ConfigurableModuleBuilder().build(), exports.HttpConfigurableModuleClass = _a.ConfigurableModuleClass, exports.HTTP_APP_OPTIONS = _a.MODULE_OPTIONS_TOKEN;

package/application/http.module.d.ts

@@ -0,0 +1,3 @@
+import { HttpConfigurableModuleClass } from "./http.module-defenition";
+export declare class HttpModule extends HttpConfigurableModuleClass {
+}

package/application/http.module.js

@@ -0,0 +1,21 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpModule = void 0;
+const http_module_defenition_1 = require("./http.module-defenition");
+const core_1 = require("../../core/index.ts");
+const module_1 = require("../../core/discovery/module");
+const http_service_1 = require("./http.service");
+let HttpModule = class HttpModule extends http_module_defenition_1.HttpConfigurableModuleClass {
+};
+exports.HttpModule = HttpModule;
+exports.HttpModule = HttpModule = __decorate([
+    (0, core_1.Module)({
+        providers: [module_1.DiscoveryModule, http_service_1.HttpCoreService],
+    })
+], HttpModule);

package/application/http.service.d.ts

@@ -0,0 +1,11 @@
+import { VenokContainer } from "@venok/core";
+import { OnApplicationShutdown, OnModuleInit } from "@venok/core/interfaces/hooks";
+import { HttpAppOptions } from "./http.module-defenition";
+export declare class HttpCoreService implements OnModuleInit, OnApplicationShutdown {
+    private readonly container;
+    private readonly options;
+    private httpStarter;
+    constructor(container: VenokContainer, options: Required<HttpAppOptions>);
+    onModuleInit(): Promise<any>;
+    onApplicationShutdown(signal?: string): Promise<void>;
+}

package/application/http.service.js

@@ -0,0 +1,43 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpCoreService = void 0;
+const core_1 = require("../../core/index.ts");
+const config_1 = require("./config");
+const starter_1 = require("./starter");
+const graph_inspector_1 = require("../../core/inspector/graph-inspector");
+const application_1 = require("./application");
+const http_module_defenition_1 = require("./http.module-defenition");
+let HttpCoreService = class HttpCoreService {
+    constructor(container, options) {
+        this.container = container;
+        this.options = options;
+    }
+    async onModuleInit() {
+        const httpConfig = new config_1.HttpConfig();
+        httpConfig.setHttpAdapter(this.options.adapter);
+        this.httpStarter = new starter_1.HttpStarter(this.container, this.options.adapter, this.container.applicationConfig, httpConfig, new graph_inspector_1.GraphInspector(this.container));
+        this.options.callback && this.options.callback(new application_1.HttpApplication(this.options.adapter, httpConfig));
+        await this.httpStarter.listen(this.options.port);
+    }
+    async onApplicationShutdown(signal) {
+        await this.httpStarter.dispose();
+    }
+};
+exports.HttpCoreService = HttpCoreService;
+exports.HttpCoreService = HttpCoreService = __decorate([
+    (0, core_1.Injectable)(),
+    __param(1, (0, core_1.Inject)(http_module_defenition_1.HTTP_APP_OPTIONS)),
+    __metadata("design:paramtypes", [core_1.VenokContainer, Object])
+], HttpCoreService);

package/application/starter.d.ts

@@ -0,0 +1,41 @@
+import { ApplicationConfig, VenokContainer } from "@venok/core";
+import { Logger } from "@venok/core/services/logger.service";
+import { HttpServer } from "../interfaces";
+import { HttpConfig } from "./config";
+import { GraphInspector } from "@venok/core/inspector/graph-inspector";
+/**
+ * @publicApi
+ */
+export declare class HttpStarter {
+    private readonly container;
+    private readonly httpAdapter;
+    private readonly config;
+    private readonly httpConfig;
+    private readonly graphInspector;
+    private readonly appOptions;
+    private readonly injector;
+    protected readonly logger: Logger;
+    private readonly middlewareModule;
+    private readonly middlewareContainer;
+    private readonly routesResolver;
+    private httpServer;
+    private isListening;
+    constructor(container: VenokContainer, httpAdapter: HttpServer, config: ApplicationConfig, httpConfig: HttpConfig, graphInspector: GraphInspector, appOptions?: any);
+    dispose(): Promise<void>;
+    registerHttpServer(): void;
+    getUnderlyingHttpServer<T>(): T;
+    createServer<T = any>(): T;
+    registerModules(): Promise<void>;
+    init(): Promise<this>;
+    registerParserMiddleware(): void;
+    registerRouter(): Promise<void>;
+    registerRouterHooks(): Promise<void>;
+    getHttpServer(): any;
+    listen(port: number | string): Promise<any>;
+    listen(port: number | string, hostname: string): Promise<any>;
+    getUrl(): Promise<string>;
+    private formatAddress;
+    private host;
+    private getProtocol;
+    private registerMiddleware;
+}

package/application/starter.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpStarter = void 0;
+const injector_1 = require("../../core/injector/injector");
+const shared_helper_1 = require("../../core/helpers/shared.helper");
+const os_1 = require("os");
+const helpers_1 = require("../helpers");
+const logger_service_1 = require("../../core/services/logger.service");
+const container_1 = require("../middleware/container");
+const module_1 = require("../middleware/module");
+const resolver_1 = require("../router/resolver");
+/**
+ * @publicApi
+ */
+class HttpStarter {
+    constructor(container, httpAdapter, config, httpConfig, graphInspector, appOptions = {}) {
+        this.container = container;
+        this.httpAdapter = httpAdapter;
+        this.config = config;
+        this.httpConfig = httpConfig;
+        this.graphInspector = graphInspector;
+        this.appOptions = appOptions;
+        this.logger = new logger_service_1.Logger(HttpStarter.name, {
+            timestamp: true,
+        });
+        this.isListening = false;
+        this.registerHttpServer();
+        this.middlewareContainer = new container_1.MiddlewareContainer(this.container);
+        this.injector = new injector_1.Injector({ preview: this.appOptions.preview });
+        this.middlewareModule = new module_1.MiddlewareModule();
+        this.routesResolver = new resolver_1.RoutesResolver(this.container, this.config, this.httpConfig, this.injector, this.graphInspector);
+    }
+    async dispose() {
+        this.httpAdapter && (await this.httpAdapter.close());
+    }
+    registerHttpServer() {
+        this.httpServer = this.createServer();
+    }
+    getUnderlyingHttpServer() {
+        return this.httpAdapter.getHttpServer();
+    }
+    createServer() {
+        this.httpAdapter.initHttpServer(this.appOptions);
+        return this.httpAdapter.getHttpServer();
+    }
+    async registerModules() {
+        await this.middlewareModule.register(this.middlewareContainer, this.container, this.config, this.httpConfig, this.injector, this.httpAdapter, this.graphInspector, this.appOptions);
+    }
+    async init() {
+        this.httpAdapter.init && (await this.httpAdapter.init());
+        const useBodyParser = this.appOptions && this.appOptions.bodyParser !== false;
+        useBodyParser && this.registerParserMiddleware();
+        await this.registerModules();
+        await this.registerRouter();
+        await this.registerRouterHooks();
+        return this;
+    }
+    registerParserMiddleware() {
+        const prefix = this.httpConfig.getGlobalPrefix();
+        const rawBody = !!this.appOptions?.rawBody;
+        this.httpAdapter.registerParserMiddleware(prefix, rawBody);
+    }
+    async registerRouter() {
+        await this.registerMiddleware(this.httpAdapter);
+        const prefix = this.httpConfig.getGlobalPrefix();
+        const basePath = (0, helpers_1.addLeadingSlash)(prefix);
+        this.routesResolver.resolve(this.httpAdapter, basePath);
+    }
+    async registerRouterHooks() {
+        this.routesResolver.registerNotFoundHandler();
+        this.routesResolver.registerExceptionHandler();
+    }
+    getHttpServer() {
+        return this.httpServer;
+    }
+    async listen(port, ...args) {
+        await this.init();
+        return new Promise((resolve, reject) => {
+            const errorHandler = (e) => {
+                this.logger.error(e?.toString?.());
+                reject(e);
+            };
+            this.httpServer.once("error", errorHandler);
+            const isCallbackInOriginalArgs = (0, shared_helper_1.isFunction)(args[args.length - 1]);
+            const listenFnArgs = isCallbackInOriginalArgs ? args.slice(0, args.length - 1) : args;
+            this.httpAdapter.listen(port, ...listenFnArgs, (...originalCallbackArgs) => {
+                if (originalCallbackArgs[0] instanceof Error)
+                    return reject(originalCallbackArgs[0]);
+                const address = this.httpServer.address();
+                if (address) {
+                    this.httpServer.removeListener("error", errorHandler);
+                    this.isListening = true;
+                    resolve(this.httpServer);
+                }
+                if (isCallbackInOriginalArgs) {
+                    args[args.length - 1](...originalCallbackArgs);
+                }
+                this.logger.log((0, helpers_1.VENOK_HTTP_SERVER_START)(port));
+            });
+        });
+    }
+    async getUrl() {
+        return new Promise((resolve, reject) => {
+            const address = this.httpServer.address();
+            resolve(this.formatAddress(address));
+        });
+    }
+    formatAddress(address) {
+        if ((0, shared_helper_1.isString)(address)) {
+            if ((0, os_1.platform)() === "win32")
+                return address;
+            const basePath = encodeURIComponent(address);
+            return `${this.getProtocol()}+unix://${basePath}`;
+        }
+        let host = this.host();
+        if (address && address.family === "IPv6") {
+            if (host === "::")
+                host = "[::1]";
+            else
+                host = `[${host}]`;
+        }
+        else if (host === "0.0.0.0") {
+            host = "127.0.0.1";
+        }
+        return `${this.getProtocol()}://${host}:${address.port}`;
+    }
+    host() {
+        const address = this.httpServer.address();
+        if ((0, shared_helper_1.isString)(address))
+            return undefined;
+        return address && address.address;
+    }
+    getProtocol() {
+        return this.appOptions && this.appOptions.httpsOptions ? "https" : "http";
+    }
+    async registerMiddleware(instance) {
+        await this.middlewareModule.registerMiddleware(this.middlewareContainer, instance);
+    }
+}
+exports.HttpStarter = HttpStarter;

package/constants.d.ts

@@ -0,0 +1,12 @@
+export declare const HOST_METADATA = "host";
+export declare const PATH_METADATA = "path";
+export declare const HEADERS_METADATA = "__headers__";
+export declare const REDIRECT_METADATA = "__redirect__";
+export declare const RESPONSE_PASSTHROUGH_METADATA = "__responsePassthrough__";
+export declare const SSE_METADATA = "__sse__";
+export declare const VERSION_METADATA = "__version__";
+export declare const CONTROLLER_WATERMARK = "__controller__";
+export declare const RENDER_METADATA = "__renderTemplate__";
+export declare const HTTP_CODE_METADATA = "__httpCode__";
+export declare const METHOD_METADATA = "method";
+export declare const REQUEST_CONTEXT_ID: unique symbol;

package/constants.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REQUEST_CONTEXT_ID = exports.METHOD_METADATA = exports.HTTP_CODE_METADATA = exports.RENDER_METADATA = exports.CONTROLLER_WATERMARK = exports.VERSION_METADATA = exports.SSE_METADATA = exports.RESPONSE_PASSTHROUGH_METADATA = exports.REDIRECT_METADATA = exports.HEADERS_METADATA = exports.PATH_METADATA = exports.HOST_METADATA = void 0;
+exports.HOST_METADATA = "host";
+exports.PATH_METADATA = "path";
+exports.HEADERS_METADATA = "__headers__";
+exports.REDIRECT_METADATA = "__redirect__";
+exports.RESPONSE_PASSTHROUGH_METADATA = "__responsePassthrough__";
+exports.SSE_METADATA = "__sse__";
+exports.VERSION_METADATA = "__version__";
+exports.CONTROLLER_WATERMARK = "__controller__";
+exports.RENDER_METADATA = "__renderTemplate__";
+exports.HTTP_CODE_METADATA = "__httpCode__";
+exports.METHOD_METADATA = "method";
+exports.REQUEST_CONTEXT_ID = Symbol("REQUEST_CONTEXT_ID");