@venok/http 1.0.1-canary.0

package/middleware/utils.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMiddlewareRouteExcluded = exports.assignToken = exports.isMiddlewareClass = exports.mapToClass = exports.filterMiddleware = exports.mapToExcludeRoute = void 0;
+const path_to_regexp_1 = require("path-to-regexp");
+const uid_1 = require("uid");
+const shared_helper_1 = require("../../core/helpers/shared.helper");
+const enums_1 = require("../enums");
+const helpers_1 = require("../helpers");
+const mapToExcludeRoute = (routes) => {
+    return routes.map((route) => {
+        if ((0, shared_helper_1.isString)(route)) {
+            return {
+                path: route,
+                requestMethod: enums_1.RequestMethod.ALL,
+                pathRegex: (0, path_to_regexp_1.pathToRegexp)((0, helpers_1.addLeadingSlash)(route)),
+            };
+        }
+        return {
+            path: route.path,
+            requestMethod: route.method,
+            pathRegex: (0, path_to_regexp_1.pathToRegexp)((0, helpers_1.addLeadingSlash)(route.path)),
+        };
+    });
+};
+exports.mapToExcludeRoute = mapToExcludeRoute;
+const filterMiddleware = (middleware, routes, httpAdapter) => {
+    const excludedRoutes = (0, exports.mapToExcludeRoute)(routes);
+    return middleware.filter(shared_helper_1.isFunction).map((item) => (0, exports.mapToClass)(item, excludedRoutes, httpAdapter));
+};
+exports.filterMiddleware = filterMiddleware;
+const mapToClass = (middleware, excludedRoutes, httpAdapter) => {
+    if (isMiddlewareClass(middleware)) {
+        if (excludedRoutes.length <= 0) {
+            return middleware;
+        }
+        const MiddlewareHost = class extends middleware {
+            use(...params) {
+                const [req, _, next] = params;
+                const isExcluded = isMiddlewareRouteExcluded(req, excludedRoutes, httpAdapter);
+                if (isExcluded) {
+                    return next();
+                }
+                return super.use(...params);
+            }
+        };
+        return assignToken(MiddlewareHost, middleware.name);
+    }
+    return assignToken(class {
+        constructor() {
+            this.use = (...params) => {
+                const [req, _, next] = params;
+                const isExcluded = isMiddlewareRouteExcluded(req, excludedRoutes, httpAdapter);
+                if (isExcluded) {
+                    return next();
+                }
+                return middleware(...params);
+            };
+        }
+    });
+};
+exports.mapToClass = mapToClass;
+function isMiddlewareClass(middleware) {
+    const middlewareStr = middleware.toString();
+    if (middlewareStr.substring(0, 5) === "class") {
+        return true;
+    }
+    const middlewareArr = middlewareStr.split(" ");
+    return (middlewareArr[0] === "function" && /[A-Z]/.test(middlewareArr[1]?.[0]) && (0, shared_helper_1.isFunction)(middleware.prototype?.use));
+}
+exports.isMiddlewareClass = isMiddlewareClass;
+function assignToken(metatype, token = (0, uid_1.uid)(21)) {
+    Object.defineProperty(metatype, "name", { value: token });
+    return metatype;
+}
+exports.assignToken = assignToken;
+function isMiddlewareRouteExcluded(req, excludedRoutes, httpAdapter) {
+    if (excludedRoutes.length <= 0 || !httpAdapter.getRequestUrl || !httpAdapter.getRequestMethod) {
+        return false;
+    }
+    const reqMethod = httpAdapter.getRequestMethod(req);
+    const originalUrl = httpAdapter.getRequestUrl(req);
+    const queryParamsIndex = originalUrl && originalUrl.indexOf("?");
+    const pathname = (0, shared_helper_1.isNumber)(queryParamsIndex) && queryParamsIndex >= 0 ? originalUrl.slice(0, +queryParamsIndex) : originalUrl;
+    return (0, helpers_1.isRouteExcluded)(excludedRoutes, pathname, enums_1.RequestMethod[reqMethod]);
+}
+exports.isMiddlewareRouteExcluded = isMiddlewareRouteExcluded;

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@venok/http",
+  "version": "1.0.1-canary.0",
+  "description": "",
+  "author": "0x303133",
+  "homepage": "",
+  "main": "index.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/venokjs/venok.git",
+    "directory": "packages/http"
+  },
+  "scripts": {
+    "build": "venok build",
+    "postbuild": "ts-node ../../tools/move.ts http",
+    "test": "mocha test/**/*.spec.ts"
+  },
+  "mocha": {
+    "require": [
+      "ts-node/register",
+      "tsconfig-paths/register",
+      "../../node_modules/reflect-metadata/Reflect.js",
+      "../../hooks/mocha-init-hook.ts"
+    ],
+    "exit": true
+  },
+  "devDependencies": {
+    "@types/eventsource": "^1.1.12",
+    "@types/http-errors": "^2.0.2",
+    "@types/path-to-regexp": "^1.7.0",
+    "eventsource": "^2.0.2",
+    "http-errors": "^2.0.0"
+  },
+  "dependencies": {
+    "@venok/core": "^1.0.1-canary.0",
+    "path-to-regexp": "^6.2.1"
+  }
+}

package/router/module.d.ts

@@ -0,0 +1,18 @@
+import { DynamicModule, ModulesContainer } from "@venok/core";
+import { Module as ModuleClass } from "@venok/core/injector/module/module";
+import { Routes } from "../interfaces";
+export declare const ROUTES: unique symbol;
+export declare const targetModulesByContainer: WeakMap<ModulesContainer, WeakSet<ModuleClass>>;
+/**
+ * @publicApi
+ */
+export declare class RouterModule {
+    private readonly modulesContainer;
+    private readonly routes;
+    constructor(modulesContainer: ModulesContainer, routes: Routes);
+    static register(routes: Routes): DynamicModule;
+    private deepCloneRoutes;
+    private initialize;
+    private registerModulePathMetadata;
+    private updateTargetModulesCache;
+}

package/router/module.js

@@ -0,0 +1,88 @@
+"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); }
+};
+var RouterModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RouterModule = exports.targetModulesByContainer = exports.ROUTES = void 0;
+const core_1 = require("../../core/index.ts");
+const helpers_1 = require("../helpers");
+const constants_1 = require("../../core/constants");
+const helpers_2 = require("../helpers");
+exports.ROUTES = Symbol("ROUTES");
+exports.targetModulesByContainer = new WeakMap();
+/**
+ * @publicApi
+ */
+let RouterModule = RouterModule_1 = class RouterModule {
+    constructor(modulesContainer, routes) {
+        this.modulesContainer = modulesContainer;
+        this.routes = routes;
+        this.routes = this.deepCloneRoutes(routes);
+        this.initialize();
+    }
+    static register(routes) {
+        return {
+            module: RouterModule_1,
+            providers: [
+                {
+                    provide: exports.ROUTES,
+                    useValue: routes,
+                },
+            ],
+        };
+    }
+    deepCloneRoutes(routes) {
+        return routes.map((routeOrType) => {
+            if (typeof routeOrType === "function")
+                return routeOrType;
+            if (routeOrType.children) {
+                return {
+                    ...routeOrType,
+                    children: this.deepCloneRoutes(routeOrType.children),
+                };
+            }
+            return { ...routeOrType };
+        });
+    }
+    initialize() {
+        const flattenedRoutes = (0, helpers_2.flattenRoutePaths)(this.routes);
+        flattenedRoutes.forEach((route) => {
+            const modulePath = (0, helpers_1.normalizePath)(route.path);
+            this.registerModulePathMetadata(route.module, modulePath);
+            this.updateTargetModulesCache(route.module);
+        });
+    }
+    registerModulePathMetadata(moduleCtor, modulePath) {
+        Reflect.defineMetadata(constants_1.MODULE_PATH + this.modulesContainer.applicationId, modulePath, moduleCtor);
+    }
+    updateTargetModulesCache(moduleCtor) {
+        let moduleClassSet;
+        if (exports.targetModulesByContainer.has(this.modulesContainer)) {
+            moduleClassSet = exports.targetModulesByContainer.get(this.modulesContainer);
+        }
+        else {
+            moduleClassSet = new WeakSet();
+            exports.targetModulesByContainer.set(this.modulesContainer, moduleClassSet);
+        }
+        const moduleRef = Array.from(this.modulesContainer.values()).find((item) => item?.metatype === moduleCtor);
+        if (!moduleRef)
+            return;
+        moduleClassSet.add(moduleRef);
+    }
+};
+exports.RouterModule = RouterModule;
+exports.RouterModule = RouterModule = RouterModule_1 = __decorate([
+    (0, core_1.Module)({}),
+    __param(1, (0, core_1.Inject)(exports.ROUTES)),
+    __metadata("design:paramtypes", [core_1.ModulesContainer, Array])
+], RouterModule);

package/router/resolver.d.ts

@@ -0,0 +1,31 @@
+import { ApplicationConfig, VenokContainer } from "@venok/core";
+import { Injector } from "@venok/core/injector/injector";
+import { GraphInspector } from "@venok/core/inspector/graph-inspector";
+import { HttpServer } from "../interfaces";
+import { InstanceWrapper } from "@venok/core/injector/instance/wrapper";
+import { HttpConfig } from "../application/config";
+export interface Resolver {
+    resolve(instance: any, basePath: string): void;
+    registerNotFoundHandler(): void;
+    registerExceptionHandler(): void;
+}
+export declare class RoutesResolver implements Resolver {
+    private readonly container;
+    private readonly applicationConfig;
+    private readonly httpConfig;
+    private readonly injector;
+    private readonly logger;
+    private readonly routerProxy;
+    private readonly routePathFactory;
+    private readonly routerExceptionsFilter;
+    private readonly routerExplorer;
+    constructor(container: VenokContainer, applicationConfig: ApplicationConfig, httpConfig: HttpConfig, injector: Injector, graphInspector: GraphInspector);
+    resolve<T extends HttpServer>(applicationRef: T, globalPrefix: string): void;
+    registerRouters(routes: Map<string | symbol | Function, InstanceWrapper<Object>>, moduleName: string, globalPrefix: string, modulePath: string, applicationRef: HttpServer): void;
+    registerNotFoundHandler(): void;
+    registerExceptionHandler(): void;
+    mapExternalException(err: any): any;
+    private getModulePathMetadata;
+    private getHostMetadata;
+    private getVersionMetadata;
+}

package/router/resolver.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoutesResolver = void 0;
+const logger_service_1 = require("../../core/services/logger.service");
+const factory_1 = require("../factory");
+const context_1 = require("../filters/context");
+const router_explorer_1 = require("../explorers/router.explorer");
+const core_1 = require("../../core/index.ts");
+const constants_1 = require("../constants");
+const constants_2 = require("../../core/constants");
+const helpers_1 = require("../helpers");
+const errors_1 = require("../errors");
+const shared_helper_1 = require("../../core/helpers/shared.helper");
+const context_2 = require("../../core/context");
+class RoutesResolver {
+    constructor(container, applicationConfig, httpConfig, injector, graphInspector) {
+        this.container = container;
+        this.applicationConfig = applicationConfig;
+        this.httpConfig = httpConfig;
+        this.injector = injector;
+        this.logger = new logger_service_1.Logger(RoutesResolver.name, {
+            timestamp: true,
+        });
+        this.routerProxy = new context_2.VenokProxy();
+        const httpAdapterRef = httpConfig.getHttpAdapterRef();
+        this.routerExceptionsFilter = new context_1.RouterExceptionFiltersContext(container, applicationConfig, httpAdapterRef);
+        this.routePathFactory = new factory_1.RoutePathFactory(this.httpConfig);
+        const metadataScanner = new core_1.MetadataScanner();
+        this.routerExplorer = new router_explorer_1.RouterExplorer(metadataScanner, this.container, this.injector, this.routerProxy, this.routerExceptionsFilter, this.applicationConfig, this.routePathFactory, graphInspector, httpConfig.getHttpAdapterRef());
+    }
+    resolve(applicationRef, globalPrefix) {
+        const modules = this.container.getModules();
+        // Change Controllers to Injectables
+        // Global change
+        modules.forEach(({ providers, metatype }, moduleName) => {
+            const modulePath = this.getModulePathMetadata(metatype);
+            this.registerRouters(providers, moduleName, globalPrefix, modulePath, applicationRef);
+        });
+    }
+    registerRouters(routes, moduleName, globalPrefix, modulePath, applicationRef) {
+        routes.forEach((instanceWrapper) => {
+            const { metatype } = instanceWrapper;
+            if ((0, shared_helper_1.isUndefined)(metatype) || (0, shared_helper_1.isNull)(metatype))
+                return;
+            if (!Reflect.hasMetadata(constants_1.CONTROLLER_WATERMARK, metatype))
+                return;
+            const host = this.getHostMetadata(metatype);
+            const routerPaths = this.routerExplorer.extractRouterPath(metatype);
+            const controllerVersion = this.getVersionMetadata(metatype);
+            const controllerName = metatype.name;
+            routerPaths.forEach((path) => {
+                const pathsToLog = this.routePathFactory.create({
+                    ctrlPath: path,
+                    modulePath,
+                    globalPrefix,
+                });
+                if (!controllerVersion) {
+                    pathsToLog.forEach((path) => {
+                        const logMessage = (0, helpers_1.CONTROLLER_MAPPING_MESSAGE)(controllerName, path);
+                        this.logger.log(logMessage);
+                    });
+                }
+                else {
+                    pathsToLog.forEach((path) => {
+                        const logMessage = (0, helpers_1.VERSIONED_CONTROLLER_MAPPING_MESSAGE)(controllerName, path, controllerVersion);
+                        this.logger.log(logMessage);
+                    });
+                }
+                const versioningOptions = this.httpConfig.getVersioning();
+                const routePathMetadata = {
+                    ctrlPath: path,
+                    modulePath,
+                    globalPrefix,
+                    controllerVersion,
+                    versioningOptions,
+                };
+                this.routerExplorer.explore(instanceWrapper, moduleName, applicationRef, host, routePathMetadata);
+            });
+        });
+    }
+    registerNotFoundHandler() {
+        const applicationRef = this.httpConfig.getHttpAdapterRef();
+        const callback = (req, res) => {
+            const method = applicationRef.getRequestMethod(req);
+            const url = applicationRef.getRequestUrl(req);
+            throw new errors_1.NotFoundException(`Cannot ${method} ${url}`);
+        };
+        const handler = this.routerExceptionsFilter.create({}, callback, undefined);
+        const proxy = this.routerProxy.createProxy(callback, handler);
+        applicationRef.setNotFoundHandler && applicationRef.setNotFoundHandler(proxy, this.httpConfig.getGlobalPrefix());
+    }
+    registerExceptionHandler() {
+        const callback = (err, req, res, next) => {
+            throw this.mapExternalException(err);
+        };
+        const handler = this.routerExceptionsFilter.create({}, callback, undefined);
+        // REFACTOR
+        const proxy = this.routerProxy.createProxy(callback, handler);
+        const applicationRef = this.httpConfig.getHttpAdapterRef();
+        if ("setErrorHandler" in applicationRef)
+            applicationRef.setErrorHandler(proxy, this.httpConfig.getGlobalPrefix());
+    }
+    mapExternalException(err) {
+        switch (true) {
+            // SyntaxError is thrown by Express body-parser when given invalid JSON (#422, #430)
+            // URIError is thrown by Express when given a path parameter with an invalid percentage
+            // encoding, e.g. '%FF' (#8915)
+            case err instanceof SyntaxError || err instanceof URIError:
+                return new errors_1.BadRequestException(err.message);
+            default:
+                return err;
+        }
+    }
+    getModulePathMetadata(metatype) {
+        const modulesContainer = this.container.getModules();
+        const modulePath = Reflect.getMetadata(constants_2.MODULE_PATH + modulesContainer.applicationId, metatype);
+        return modulePath ?? Reflect.getMetadata(constants_2.MODULE_PATH, metatype);
+    }
+    getHostMetadata(metatype) {
+        return Reflect.getMetadata(constants_1.HOST_METADATA, metatype);
+    }
+    getVersionMetadata(metatype) {
+        const versioningConfig = this.httpConfig.getVersioning();
+        if (versioningConfig)
+            return Reflect.getMetadata(constants_1.VERSION_METADATA, metatype) ?? versioningConfig.defaultVersion;
+    }
+}
+exports.RoutesResolver = RoutesResolver;

package/storage/http-instance.storage.d.ts

@@ -0,0 +1,9 @@
+import { AbstractHttpAdapter } from "../adapter/adapter";
+import { HttpAdapterHost } from "../adapter/host";
+export declare class HttpInstanceStorage {
+    private readonly _httpAdapterHost;
+    private _httpAdapter;
+    get httpAdapterHost(): HttpAdapterHost;
+    get httpAdapter(): AbstractHttpAdapter;
+    set httpAdapter(httpAdapter: AbstractHttpAdapter);
+}

package/storage/http-instance.storage.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpInstanceStorage = void 0;
+const host_1 = require("../adapter/host");
+class HttpInstanceStorage {
+    constructor() {
+        this._httpAdapterHost = new host_1.HttpAdapterHost();
+    }
+    get httpAdapterHost() {
+        return this._httpAdapterHost;
+    }
+    get httpAdapter() {
+        return this._httpAdapter;
+    }
+    set httpAdapter(httpAdapter) {
+        this._httpAdapter = httpAdapter;
+    }
+}
+exports.HttpInstanceStorage = HttpInstanceStorage;

package/stream/index.d.ts

@@ -0,0 +1 @@
+export * from "./streamable-file";

package/stream/index.js

@@ -0,0 +1,17 @@
+"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("./streamable-file"), exports);

package/stream/interfaces/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./streamable-options.interface";
+export * from "./streamable-handler-response.interface";

package/stream/interfaces/index.js

@@ -0,0 +1,18 @@
+"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("./streamable-options.interface"), exports);
+__exportStar(require("./streamable-handler-response.interface"), exports);

package/stream/interfaces/streamable-handler-response.interface.d.ts

@@ -0,0 +1,12 @@
+export interface StreamableHandlerResponse {
+    /** `true` if the connection is destroyed, `false` otherwise. */
+    destroyed: boolean;
+    /** `true` if headers were sent, `false` otherwise. */
+    headersSent: boolean;
+    /** The status code that will be sent to the client when the headers get flushed. */
+    statusCode: number;
+    /** Sends the HTTP response. */
+    send: (body: string) => void;
+    /** Signals to the server that all the response headers and body have been sent. */
+    end: () => void;
+}

package/stream/interfaces/streamable-handler-response.interface.js

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

package/stream/interfaces/streamable-options.interface.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Options for `StreamableFile`
+ *
+ * @publicApi
+ */
+export interface StreamableFileOptions {
+    type?: string;
+    disposition?: string;
+    length?: number;
+}

package/stream/interfaces/streamable-options.interface.js

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

package/stream/streamable-file.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+import { Readable } from "stream";
+import { StreamableFileOptions, StreamableHandlerResponse } from "./interfaces";
+/**
+ *
+ * @publicApi
+ */
+export declare class StreamableFile {
+    readonly options: StreamableFileOptions;
+    private readonly stream;
+    protected handleError: (err: Error, response: StreamableHandlerResponse) => void;
+    constructor(buffer: Uint8Array, options?: StreamableFileOptions);
+    constructor(readable: Readable, options?: StreamableFileOptions);
+    getStream(): Readable;
+    getHeaders(): {
+        type: string;
+        disposition: string | undefined;
+        length: number | undefined;
+    };
+    get errorHandler(): (err: Error, response: StreamableHandlerResponse) => void;
+    setErrorHandler(handler: (err: Error, response: StreamableHandlerResponse) => void): this;
+}

package/stream/streamable-file.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamableFile = void 0;
+const stream_1 = require("../../../../../../stream");
+const util_1 = require("util");
+const enums_1 = require("../enums");
+const shared_helper_1 = require("../../core/helpers/shared.helper");
+/**
+ *
+ * @publicApi
+ */
+class StreamableFile {
+    constructor(bufferOrReadStream, options = {}) {
+        this.options = options;
+        this.handleError = (err, res) => {
+            if (res.destroyed) {
+                return;
+            }
+            if (res.headersSent) {
+                res.end();
+                return;
+            }
+            res.statusCode = enums_1.HttpStatus.BAD_REQUEST;
+            res.send(err.message);
+        };
+        if (util_1.types.isUint8Array(bufferOrReadStream)) {
+            this.stream = new stream_1.Readable();
+            this.stream.push(bufferOrReadStream);
+            this.stream.push(null);
+            this.options.length ??= bufferOrReadStream.length;
+        }
+        else if (bufferOrReadStream.pipe && (0, shared_helper_1.isFunction)(bufferOrReadStream.pipe)) {
+            this.stream = bufferOrReadStream;
+        }
+    }
+    getStream() {
+        return this.stream;
+    }
+    getHeaders() {
+        const { type = "application/octet-stream", disposition = undefined, length = undefined } = this.options;
+        return {
+            type,
+            disposition,
+            length,
+        };
+    }
+    get errorHandler() {
+        return this.handleError;
+    }
+    setErrorHandler(handler) {
+        this.handleError = handler;
+        return this;
+    }
+}
+exports.StreamableFile = StreamableFile;

package/test/context/response.controller.spec.d.ts

@@ -0,0 +1 @@
+export {};