@venok/http 1.0.1-canary.0

package/factory/path.factory.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoutePathFactory = void 0;
+const interfaces_1 = require("../interfaces");
+const enums_1 = require("../enums");
+const flatten_helper_1 = require("../../core/helpers/flatten.helper");
+const helpers_1 = require("../helpers");
+const shared_helper_1 = require("../../core/helpers/shared.helper");
+class RoutePathFactory {
+    constructor(config) {
+        this.config = config;
+    }
+    create(metadata, requestMethod) {
+        let paths = [""];
+        const versionOrVersions = this.getVersion(metadata);
+        if (versionOrVersions && metadata.versioningOptions?.type === enums_1.VersioningType.URI) {
+            const versionPrefix = this.getVersionPrefix(metadata.versioningOptions);
+            if (Array.isArray(versionOrVersions)) {
+                paths = (0, flatten_helper_1.flatten)(paths.map((path) => versionOrVersions.map((version) => 
+                // Version Neutral - Do not include version in URL
+                version === interfaces_1.VERSION_NEUTRAL ? path : `${path}/${versionPrefix}${version}`)));
+            }
+            else {
+                // Version Neutral - Do not include version in URL
+                if (versionOrVersions !== interfaces_1.VERSION_NEUTRAL) {
+                    paths = paths.map((path) => `${path}/${versionPrefix}${versionOrVersions}`);
+                }
+            }
+        }
+        paths = this.appendToAllIfDefined(paths, metadata.modulePath);
+        paths = this.appendToAllIfDefined(paths, metadata.ctrlPath);
+        paths = this.appendToAllIfDefined(paths, metadata.methodPath);
+        if (metadata.globalPrefix) {
+            paths = paths.map((path) => {
+                if (this.isExcludedFromGlobalPrefix(path, requestMethod, versionOrVersions, metadata.versioningOptions)) {
+                    return path;
+                }
+                return (0, helpers_1.stripEndSlash)(metadata.globalPrefix || "") + path;
+            });
+        }
+        return paths.map((path) => (0, helpers_1.addLeadingSlash)(path || "/")).map((path) => (path !== "/" ? (0, helpers_1.stripEndSlash)(path) : path));
+    }
+    getVersion(metadata) {
+        // The version will be either the path version or the controller version,
+        // with the pathVersion taking priority.
+        return metadata.methodVersion || metadata.controllerVersion;
+    }
+    getVersionPrefix(versioningOptions) {
+        const defaultPrefix = "v";
+        if (versioningOptions.type === enums_1.VersioningType.URI) {
+            if (versioningOptions.prefix === false) {
+                return "";
+            }
+            else if (versioningOptions.prefix !== undefined) {
+                return versioningOptions.prefix;
+            }
+        }
+        return defaultPrefix;
+    }
+    appendToAllIfDefined(paths, fragmentToAppend) {
+        if (!fragmentToAppend) {
+            return paths;
+        }
+        const concatPaths = (a, b) => (0, helpers_1.stripEndSlash)(a) + (0, helpers_1.addLeadingSlash)(b);
+        if (Array.isArray(fragmentToAppend)) {
+            const paths2dArray = paths.map((path) => fragmentToAppend.map((fragment) => concatPaths(path, fragment)));
+            return (0, flatten_helper_1.flatten)(paths2dArray);
+        }
+        return paths.map((path) => concatPaths(path, fragmentToAppend));
+    }
+    isExcludedFromGlobalPrefix(path, requestMethod, versionOrVersions, versioningOptions) {
+        if ((0, shared_helper_1.isUndefined)(requestMethod)) {
+            return false;
+        }
+        const options = this.config.getGlobalPrefixOptions();
+        const excludedRoutes = options.exclude;
+        if (versionOrVersions && versionOrVersions !== interfaces_1.VERSION_NEUTRAL && versioningOptions?.type === enums_1.VersioningType.URI) {
+            path = this.truncateVersionPrefixFromPath(path, versionOrVersions, versioningOptions);
+        }
+        return Array.isArray(excludedRoutes) && (0, helpers_1.isRouteExcluded)(excludedRoutes, path, requestMethod);
+    }
+    truncateVersionPrefixFromPath(path, versionValue, versioningOptions) {
+        if (typeof versionValue !== "string") {
+            versionValue.forEach((version) => {
+                if (typeof version === "string") {
+                    path = this.truncateVersionPrefixFromPath(path, version, versioningOptions);
+                }
+            });
+            return path;
+        }
+        const prefix = `/${this.getVersionPrefix(versioningOptions)}${versionValue}`;
+        return path.startsWith(prefix) ? path.replace(prefix, "") : path;
+    }
+}
+exports.RoutePathFactory = RoutePathFactory;

package/filters/context.d.ts

@@ -0,0 +1,9 @@
+import { ApplicationConfig, VenokContainer } from "@venok/core";
+import { HttpServer } from "../interfaces";
+import { HttpExceptionFilter } from "./filter";
+import { VenokExceptionFilterContext } from "@venok/core/filters/context";
+export declare class RouterExceptionFiltersContext extends VenokExceptionFilterContext {
+    private readonly applicationRef;
+    constructor(container: VenokContainer, config: ApplicationConfig, applicationRef: HttpServer);
+    getExceptionFilter(): HttpExceptionFilter<any>;
+}

package/filters/context.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RouterExceptionFiltersContext = void 0;
+const filter_1 = require("./filter");
+const context_1 = require("../../core/filters/context");
+class RouterExceptionFiltersContext extends context_1.VenokExceptionFilterContext {
+    constructor(container, config, applicationRef) {
+        super(container, config);
+        this.applicationRef = applicationRef;
+    }
+    getExceptionFilter() {
+        return new filter_1.HttpExceptionFilter(this.applicationRef);
+    }
+}
+exports.RouterExceptionFiltersContext = RouterExceptionFiltersContext;

package/filters/filter.d.ts

@@ -0,0 +1,22 @@
+import { ExceptionFilter } from "@venok/core/interfaces/features/exception-filter.interface";
+import { ArgumentsHost } from "@venok/core/interfaces/context/arguments-host.interface";
+import { HttpServer } from "../interfaces";
+import { HttpAdapterHost } from "../adapter/host";
+import { AbstractHttpAdapter } from "../adapter/adapter";
+export declare class HttpExceptionFilter<T = any> implements ExceptionFilter<T> {
+    protected readonly applicationRef?: HttpServer<any, any, any> | undefined;
+    private static readonly logger;
+    protected readonly httpAdapterHost?: HttpAdapterHost;
+    constructor(applicationRef?: HttpServer<any, any, any> | undefined);
+    catch(exception: T, host: ArgumentsHost): void;
+    handleUnknownError(exception: T, host: ArgumentsHost, applicationRef: AbstractHttpAdapter | HttpServer): void;
+    isExceptionObject(err: any): err is Error;
+    /**
+     * Checks if the thrown error comes from the "http-errors" library.
+     * @param err error object
+     */
+    isHttpError(err: any): err is {
+        statusCode: number;
+        message: string;
+    };
+}

package/filters/filter.js

@@ -0,0 +1,78 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpExceptionFilter = void 0;
+const logger_service_1 = require("../../core/services/logger.service");
+const core_1 = require("../../core/index.ts");
+const shared_helper_1 = require("../../core/helpers/shared.helper");
+const constants_1 = require("../../core/constants");
+const enums_1 = require("../enums");
+const host_1 = require("../adapter/host");
+const errors_1 = require("../errors");
+class HttpExceptionFilter {
+    constructor(applicationRef) {
+        this.applicationRef = applicationRef;
+    }
+    catch(exception, host) {
+        const applicationRef = this.applicationRef || (this.httpAdapterHost && this.httpAdapterHost.httpAdapter);
+        if (!(exception instanceof errors_1.HttpException)) {
+            return this.handleUnknownError(exception, host, applicationRef);
+        }
+        const res = exception.getResponse();
+        const message = (0, shared_helper_1.isObject)(res)
+            ? res
+            : {
+                statusCode: exception.getStatus(),
+                message: res,
+            };
+        const response = host.getArgByIndex(1);
+        if (!applicationRef.isHeadersSent(response))
+            applicationRef.reply(response, message, exception.getStatus());
+        else
+            applicationRef.end(response);
+    }
+    handleUnknownError(exception, host, applicationRef) {
+        const body = this.isHttpError(exception)
+            ? {
+                statusCode: exception.statusCode,
+                message: exception.message,
+            }
+            : {
+                statusCode: enums_1.HttpStatus.INTERNAL_SERVER_ERROR,
+                message: constants_1.MESSAGES.UNKNOWN_EXCEPTION_MESSAGE,
+            };
+        const response = host.getArgByIndex(1);
+        if (!applicationRef.isHeadersSent(response))
+            applicationRef.reply(response, body, body.statusCode);
+        else
+            applicationRef.end(response);
+        if (this.isExceptionObject(exception))
+            return HttpExceptionFilter.logger.error(exception.message, exception.stack);
+        return HttpExceptionFilter.logger.error(exception);
+    }
+    isExceptionObject(err) {
+        return (0, shared_helper_1.isObject)(err) && !!err.message;
+    }
+    /**
+     * Checks if the thrown error comes from the "http-errors" library.
+     * @param err error object
+     */
+    isHttpError(err) {
+        return err?.statusCode && err?.message;
+    }
+}
+exports.HttpExceptionFilter = HttpExceptionFilter;
+HttpExceptionFilter.logger = new logger_service_1.Logger("ExceptionsHandler");
+__decorate([
+    (0, core_1.Optional)(),
+    (0, core_1.Inject)(),
+    __metadata("design:type", host_1.HttpAdapterHost)
+], HttpExceptionFilter.prototype, "httpAdapterHost", void 0);

package/helpers/adapter.helper.d.ts

@@ -0,0 +1,27 @@
+import { AbstractHttpAdapter } from "@venok/http/adapter/adapter";
+import { RequestMethod } from "@venok/http/enums";
+import { VersioningOptions, VersionValue } from "../interfaces/router/version-options.interface";
+export declare class NoopHttpAdapter extends AbstractHttpAdapter {
+    constructor(instance: any);
+    close(): any;
+    initHttpServer(options: any): any;
+    useStaticAssets(...args: any[]): any;
+    setViewEngine(engine: string): any;
+    getRequestHostname(request: any): any;
+    getRequestMethod(request: any): any;
+    getRequestUrl(request: any): any;
+    reply(response: any, body: any): any;
+    end(response: any, message?: any): any;
+    status(response: any, statusCode: number): any;
+    render(response: any, view: string, options: any): any;
+    redirect(response: any, statusCode: number, url: string): void;
+    setErrorHandler(handler: Function, prefix?: string): any;
+    setNotFoundHandler(handler: Function, prefix?: string): any;
+    isHeadersSent(response: any): any;
+    setHeader(response: any, name: string, value: string): any;
+    registerParserMiddleware(): any;
+    enableCors(options: any): any;
+    createMiddlewareFactory(requestMethod: RequestMethod): any;
+    getType(): string;
+    applyVersionFilter(handler: Function, version: VersionValue, versioningOptions: VersioningOptions): (req: any, res: any, next: any) => () => void;
+}

package/helpers/adapter.helper.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoopHttpAdapter = void 0;
+const adapter_1 = require("@venok/http/adapter/adapter");
+class NoopHttpAdapter extends adapter_1.AbstractHttpAdapter {
+    constructor(instance) {
+        super(instance);
+    }
+    close() { }
+    initHttpServer(options) { }
+    useStaticAssets(...args) { }
+    setViewEngine(engine) { }
+    getRequestHostname(request) { }
+    getRequestMethod(request) { }
+    getRequestUrl(request) { }
+    reply(response, body) { }
+    end(response, message) { }
+    status(response, statusCode) { }
+    render(response, view, options) { }
+    redirect(response, statusCode, url) { }
+    setErrorHandler(handler, prefix = "/") { }
+    setNotFoundHandler(handler, prefix = "/") { }
+    isHeadersSent(response) { }
+    setHeader(response, name, value) { }
+    registerParserMiddleware() { }
+    enableCors(options) { }
+    createMiddlewareFactory(requestMethod) { }
+    getType() {
+        return "";
+    }
+    applyVersionFilter(handler, version, versioningOptions) {
+        return (req, res, next) => {
+            return () => { };
+        };
+    }
+}
+exports.NoopHttpAdapter = NoopHttpAdapter;

package/helpers/exclude-route.helper.d.ts

@@ -0,0 +1,4 @@
+import { RequestMethod } from "../enums";
+import { ExcludeRouteMetadata } from "../interfaces/http/exclude-route.interface";
+export declare const isRequestMethodAll: (method: RequestMethod) => boolean;
+export declare function isRouteExcluded(excludedRoutes: ExcludeRouteMetadata[], path: string, requestMethod?: RequestMethod): boolean;

package/helpers/exclude-route.helper.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRouteExcluded = exports.isRequestMethodAll = void 0;
+const enums_1 = require("../enums");
+const path_helper_1 = require("./path.helper");
+const isRequestMethodAll = (method) => {
+    return enums_1.RequestMethod.ALL === method || method === -1;
+};
+exports.isRequestMethodAll = isRequestMethodAll;
+function isRouteExcluded(excludedRoutes, path, requestMethod) {
+    return excludedRoutes.some((route) => {
+        if ((0, exports.isRequestMethodAll)(route.requestMethod) || route.requestMethod === requestMethod) {
+            return route.pathRegex.exec((0, path_helper_1.addLeadingSlash)(path));
+        }
+        return false;
+    });
+}
+exports.isRouteExcluded = isRouteExcluded;

package/helpers/flatten-routes.helper.d.ts

@@ -0,0 +1,5 @@
+import { Routes } from "../interfaces/http/routes.interface";
+export declare function flattenRoutePaths(routes: Routes): {
+    module: any;
+    path: string;
+}[];

package/helpers/flatten-routes.helper.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flattenRoutePaths = void 0;
+const shared_helper_1 = require("../../core/helpers/shared.helper");
+const path_helper_1 = require("./path.helper");
+function flattenRoutePaths(routes) {
+    const result = [];
+    routes.forEach((item) => {
+        if (item.module && item.path) {
+            result.push({ module: item.module, path: item.path });
+        }
+        if (item.children) {
+            const childrenRef = item.children;
+            childrenRef.forEach((child) => {
+                if (!(0, shared_helper_1.isString)(child) && child.path) {
+                    child.path = (0, path_helper_1.normalizePath)((0, path_helper_1.normalizePath)(item.path) + (0, path_helper_1.normalizePath)(child.path));
+                }
+                else {
+                    result.push({ path: item.path, module: child });
+                }
+            });
+            result.push(...flattenRoutePaths(childrenRef));
+        }
+    });
+    return result;
+}
+exports.flattenRoutePaths = flattenRoutePaths;

package/helpers/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./adapter.helper";
+export * from "./exclude-route.helper";
+export * from "./flatten-routes.helper";
+export * from "./messages.helper";
+export * from "./path.helper";
+export * from "./sse.helper";

package/helpers/index.js

@@ -0,0 +1,22 @@
+"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("./adapter.helper"), exports);
+__exportStar(require("./exclude-route.helper"), exports);
+__exportStar(require("./flatten-routes.helper"), exports);
+__exportStar(require("./messages.helper"), exports);
+__exportStar(require("./path.helper"), exports);
+__exportStar(require("./sse.helper"), exports);

package/helpers/messages.helper.d.ts

@@ -0,0 +1,6 @@
+import { VersionValue } from "../interfaces/router/version-options.interface";
+export declare const ROUTE_MAPPED_MESSAGE: (path: string, method: string | number) => string;
+export declare const VERSIONED_ROUTE_MAPPED_MESSAGE: (path: string, method: string | number, version: VersionValue) => string;
+export declare const CONTROLLER_MAPPING_MESSAGE: (name: string, path: string) => string;
+export declare const VERSIONED_CONTROLLER_MAPPING_MESSAGE: (name: string, path: string, version: VersionValue) => string;
+export declare const VENOK_HTTP_SERVER_START: (port: string | number) => string;

package/helpers/messages.helper.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VENOK_HTTP_SERVER_START = exports.VERSIONED_CONTROLLER_MAPPING_MESSAGE = exports.CONTROLLER_MAPPING_MESSAGE = exports.VERSIONED_ROUTE_MAPPED_MESSAGE = exports.ROUTE_MAPPED_MESSAGE = void 0;
+const enums_1 = require("../enums");
+const version_options_interface_1 = require("../interfaces/router/version-options.interface");
+const ROUTE_MAPPED_MESSAGE = (path, method) => `Mapped {${path}, ${enums_1.RequestMethod[method]}} route`;
+exports.ROUTE_MAPPED_MESSAGE = ROUTE_MAPPED_MESSAGE;
+const VERSIONED_ROUTE_MAPPED_MESSAGE = (path, method, version) => {
+    const controllerVersions = Array.isArray(version) ? version : [version];
+    const versions = controllerVersions.map((version) => (version === version_options_interface_1.VERSION_NEUTRAL ? "Neutral" : version)).join(",");
+    return `Mapped {${path}, ${enums_1.RequestMethod[method]}} (version: ${versions}) route`;
+};
+exports.VERSIONED_ROUTE_MAPPED_MESSAGE = VERSIONED_ROUTE_MAPPED_MESSAGE;
+const CONTROLLER_MAPPING_MESSAGE = (name, path) => `${name} {${path}}:`;
+exports.CONTROLLER_MAPPING_MESSAGE = CONTROLLER_MAPPING_MESSAGE;
+const VERSIONED_CONTROLLER_MAPPING_MESSAGE = (name, path, version) => {
+    const controllerVersions = Array.isArray(version) ? version : [version];
+    const versions = controllerVersions.map((version) => (version === version_options_interface_1.VERSION_NEUTRAL ? "Neutral" : version)).join(",");
+    return `${name} {${path}} (version: ${versions}):`;
+};
+exports.VERSIONED_CONTROLLER_MAPPING_MESSAGE = VERSIONED_CONTROLLER_MAPPING_MESSAGE;
+const VENOK_HTTP_SERVER_START = (port) => {
+    return `Venok start Http server on port: ${port}`;
+};
+exports.VENOK_HTTP_SERVER_START = VENOK_HTTP_SERVER_START;

package/helpers/path.helper.d.ts

@@ -0,0 +1,3 @@
+export declare const addLeadingSlash: (path?: string) => string;
+export declare const normalizePath: (path?: string) => string;
+export declare const stripEndSlash: (path: string) => string;

package/helpers/path.helper.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripEndSlash = exports.normalizePath = exports.addLeadingSlash = void 0;
+const addLeadingSlash = (path) => path && typeof path === "string" ? (path.charAt(0) !== "/" ? "/" + path : path) : "";
+exports.addLeadingSlash = addLeadingSlash;
+const normalizePath = (path) => path
+    ? path.startsWith("/")
+        ? ("/" + path.replace(/\/+$/, "")).replace(/\/+/g, "/")
+        : "/" + path.replace(/\/+$/, "")
+    : "/";
+exports.normalizePath = normalizePath;
+const stripEndSlash = (path) => (path[path.length - 1] === "/" ? path.slice(0, path.length - 1) : path);
+exports.stripEndSlash = stripEndSlash;

package/helpers/sse.helper.d.ts

@@ -0,0 +1,45 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { IncomingMessage, OutgoingHttpHeaders } from "http";
+import { Transform } from "stream";
+import { MessageEvent } from "@venok/http/interfaces/http/message-event.interface";
+export type AdditionalHeaders = Record<string, string[] | string | number | undefined>;
+interface ReadHeaders {
+    getHeaders?(): AdditionalHeaders;
+}
+interface WriteHeaders {
+    writableEnded?: boolean;
+    writeHead?(statusCode: number, reasonPhrase?: string, headers?: OutgoingHttpHeaders): void;
+    writeHead?(statusCode: number, headers?: OutgoingHttpHeaders): void;
+    flushHeaders?(): void;
+}
+export type WritableHeaderStream = NodeJS.WritableStream & WriteHeaders;
+export type HeaderStream = WritableHeaderStream & ReadHeaders;
+/**
+ * Adapted from https://raw.githubusercontent.com/EventSource/node-ssestream
+ * Transforms "messages" to W3C event stream content.
+ * See https://html.spec.whatwg.org/multipage/server-sent-events.html
+ * A message is an object with one or more of the following properties:
+ * - data (String or object, which gets turned into JSON)
+ * - type
+ * - id
+ * - retry
+ *
+ * If constructed with an HTTP Request, it will optimise the socket for streaming.
+ * If this stream is piped to an HTTP Response, it will set appropriate headers.
+ */
+export declare class SseStream extends Transform {
+    private lastEventId;
+    constructor(req?: IncomingMessage);
+    pipe<T extends WritableHeaderStream>(destination: T, options?: {
+        additionalHeaders?: AdditionalHeaders;
+        end?: boolean;
+    }): T;
+    _transform(message: MessageEvent, encoding: string, callback: (error?: Error | null, data?: any) => void): void;
+    /**
+     * Calls `.write` but handles the drain if needed
+     */
+    writeMessage(message: MessageEvent, cb: (error: Error | null | undefined) => void): void;
+}
+export {};

package/helpers/sse.helper.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SseStream = void 0;
+const stream_1 = require("../../../../../../stream");
+const shared_helper_1 = require("../../core/helpers/shared.helper");
+function toDataString(data) {
+    if ((0, shared_helper_1.isObject)(data)) {
+        return toDataString(JSON.stringify(data));
+    }
+    return data
+        .split(/\r\n|\r|\n/)
+        .map((line) => `data: ${line}\n`)
+        .join("");
+}
+/**
+ * Adapted from https://raw.githubusercontent.com/EventSource/node-ssestream
+ * Transforms "messages" to W3C event stream content.
+ * See https://html.spec.whatwg.org/multipage/server-sent-events.html
+ * A message is an object with one or more of the following properties:
+ * - data (String or object, which gets turned into JSON)
+ * - type
+ * - id
+ * - retry
+ *
+ * If constructed with an HTTP Request, it will optimise the socket for streaming.
+ * If this stream is piped to an HTTP Response, it will set appropriate headers.
+ */
+class SseStream extends stream_1.Transform {
+    constructor(req) {
+        super({ objectMode: true });
+        this.lastEventId = 0;
+        if (req && req.socket) {
+            req.socket.setKeepAlive(true);
+            req.socket.setNoDelay(true);
+            req.socket.setTimeout(0);
+        }
+    }
+    pipe(destination, options) {
+        if (destination.writeHead) {
+            destination.writeHead(200, {
+                ...options?.additionalHeaders,
+                // See https://github.com/dunglas/mercure/blob/master/hub/subscribe.go#L124-L130
+                "Content-Type": "text/event-stream",
+                Connection: "keep-alive",
+                // Disable cache, even for old browsers and proxies
+                "Cache-Control": "private, no-cache, no-store, must-revalidate, max-age=0, no-transform",
+                Pragma: "no-cache",
+                Expire: "0",
+                // NGINX support https://www.nginx.com/resources/wiki/start/topics/examples/x-accel/#x-accel-buffering
+                "X-Accel-Buffering": "no",
+            });
+            if (destination.flushHeaders)
+                destination.flushHeaders();
+        }
+        destination.write("\n");
+        return super.pipe(destination, options);
+    }
+    _transform(message, encoding, callback) {
+        let data = message.type ? `event: ${message.type}\n` : "";
+        data += message.id ? `id: ${message.id}\n` : "";
+        data += message.retry ? `retry: ${message.retry}\n` : "";
+        data += message.data ? toDataString(message.data) : "";
+        data += "\n";
+        this.push(data);
+        callback();
+    }
+    /**
+     * Calls `.write` but handles the drain if needed
+     */
+    writeMessage(message, cb) {
+        if (!message.id) {
+            this.lastEventId++;
+            message.id = this.lastEventId.toString();
+        }
+        if (!this.write(message, "utf-8", cb)) {
+            this.once("drain", cb);
+        }
+        else {
+            process.nextTick(cb);
+        }
+    }
+}
+exports.SseStream = SseStream;

package/index.d.ts

@@ -0,0 +1 @@
+import "reflect-metadata";

package/index.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");

package/interfaces/http/cors.interface.d.ts

@@ -0,0 +1,58 @@
+type StaticOrigin = boolean | string | RegExp | (string | RegExp)[];
+/**
+ * Set origin to a function implementing some custom logic. The function takes the
+ * request origin as the first parameter and a callback (which expects the signature
+ * err [object], allow [bool]) as the second.
+ *
+ * @see https://github.com/expressjs/cors
+ *
+ * @publicApi
+ */
+export type CustomOrigin = (requestOrigin: string, callback: (err: Error | null, origin?: StaticOrigin) => void) => void;
+/**
+ * Interface describing CORS options that can be set.
+ *
+ * @see https://github.com/expressjs/cors
+ * @publicApi
+ */
+export interface CorsOptions {
+    /**
+     * Configures the `Access-Control-Allow-Origins` CORS header.  See [here for more detail.](https://github.com/expressjs/cors#configuration-options)
+     */
+    origin?: StaticOrigin | CustomOrigin;
+    /**
+     * Configures the Access-Control-Allow-Methods CORS header.
+     */
+    methods?: string | string[];
+    /**
+     * Configures the Access-Control-Allow-Headers CORS header.
+     */
+    allowedHeaders?: string | string[];
+    /**
+     * Configures the Access-Control-Expose-Headers CORS header.
+     */
+    exposedHeaders?: string | string[];
+    /**
+     * Configures the Access-Control-Allow-Credentials CORS header.
+     */
+    credentials?: boolean;
+    /**
+     * Configures the Access-Control-Max-Age CORS header.
+     */
+    maxAge?: number;
+    /**
+     * Whether to pass the CORS preflight response to the next handler.
+     */
+    preflightContinue?: boolean;
+    /**
+     * Provides a status code to use for successful OPTIONS requests.
+     */
+    optionsSuccessStatus?: number;
+}
+export interface CorsOptionsCallback {
+    s(error: Error, options: CorsOptions): void;
+}
+export interface CorsOptionsDelegate<T> {
+    (req: T, cb: CorsOptionsCallback): void;
+}
+export {};

package/interfaces/http/cors.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/interfaces/http/exception.interface.d.ts

@@ -0,0 +1,6 @@
+export type HttpExceptionBodyMessage = string | string[];
+export interface HttpExceptionBody {
+    message: HttpExceptionBodyMessage;
+    error?: string;
+    statusCode: number;
+}

package/interfaces/http/exception.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });