@deepkit/http 1.0.1-alpha.98 → 1.0.1

package/src/request-parser.ts

@@ -1,60 +1,67 @@
 import { asyncOperation, ClassType, CompilerContext, getClassName, isObject } from '@deepkit/core';
-import { InjectorModule } from '@deepkit/injector';
+import { DependenciesUnmetError, InjectorModule } from '@deepkit/injector';
 import {
     assertType,
     findMember,
     getSerializeFunction,
     getValidatorFunction,
-    metaAnnotation,
+    hasDefaultValue,
+    isOptional,
     ReflectionKind,
     ReflectionParameter,
     resolveReceiveType,
     serializer,
     stringifyType,
     Type,
+    typeAnnotation,
     typeToObject,
-    ValidationError
+    ValidationError,
 } from '@deepkit/type';
 import { BodyValidationError, createRequestWithCachedBody, getRegExp, HttpRequest, ValidatedBody } from './model.js';
-import { RouteConfig, UploadedFile } from './router.js';
-
-//@ts-ignore
+import { getRouteActionLabel, RouteConfig, UploadedFile, UploadedFileSymbol } from './router.js';
 import qs from 'qs';
-
-// @ts-ignore
-import formidable from 'formidable';
+import formidable, { Fields, Files, Options } from 'formidable';
 import { HttpParserOptions } from './module.config.js';
 
-
 function parseBody(
     options: HttpParserOptions,
     req: HttpRequest, foundFiles: { [name: string]: UploadedFile }) {
-    const form = formidable(Object.assign(options, {
+
+    const form = formidable(Object.assign(options as Options, {
         multiples: true,
     }));
-    return asyncOperation((resolve, reject) => {
-        function parseData(err: any, fields: any, files: any) {
-            if (err) {
-                reject(err);
-            } else {
-                for (const [name, file] of Object.entries(files) as any) {
-                    if (file.size === 0) continue;
-                    foundFiles[name] = {
-                        size: file.size,
-                        path: file.filepath,
-                        name: file.originalFilename,
-                        type: file.mimetype,
-                        lastModifiedDate: file.lastModifiedDate,
-                    };
-                }
-                const body = { ...fields, ...foundFiles };
-                resolve(body);
+    return asyncOperation(async (resolve, reject) => {
+        function parseData(fields: Fields, files: Files) {
+            const fileEntries = Object.entries(files);
+
+            // formidable turns JSON arrays into numerically keyed objects, so we convert them back
+            if ('0' in fields && fileEntries.length === 0 && Object.keys(fields).every((key, idx) => parseInt(key) === idx)) {
+                return resolve(Object.values(fields));
             }
+
+            for (const [name, files] of fileEntries) {
+                if (!files) continue;
+                const file = files[0];
+                if (!file) continue;
+                if (!file.filepath || 'string' !== typeof file.filepath) continue;
+                if (!file.size || 'number' !== typeof file.size) continue;
+
+                foundFiles[name] = {
+                    validator: UploadedFileSymbol,
+                    size: file.size,
+                    path: file.filepath,
+                    name: file.originalFilename || null,
+                    type: file.mimetype || null,
+                    lastModifiedDate: null,
+                };
+            }
+            const body = { ...fields, ...foundFiles };
+            resolve(body);
         }
 
         if (req.body) {
-            form.parse(createRequestWithCachedBody(req, req.body), parseData);
-            return;
+            const [fields, files] = await form.parse(createRequestWithCachedBody(req, req.body));
+            parseData(fields, files);
         }
 
         const chunks: Buffer[] = [];
@@ -70,7 +77,8 @@ function parseBody(
         });
         req.once('error', () => req.off('data', read));
 
-        form.parse(req, parseData);
+        const [fields, files] = await form.parse(req);
+        parseData(fields, files);
     });
 }
 
@@ -83,14 +91,23 @@ export class ParameterForRequestParser {
     }
 
     get body() {
-        return metaAnnotation.getForName(this.parameter.type, 'httpBody') !== undefined;
+        return typeAnnotation.getType(this.parameter.type, 'httpBody') !== undefined;
+    }
+
+    get requestParser() {
+        return typeAnnotation.getType(this.parameter.type, 'httpRequestParser') !== undefined;
     }
 
     get bodyValidation() {
-        return metaAnnotation.getForName(this.parameter.type, 'httpBodyValidation') !== undefined;
+        return typeAnnotation.getType(this.parameter.type, 'httpBodyValidation') !== undefined;
     }
 
     getType(): Type {
+        const parser = typeAnnotation.getType(this.parameter.type, 'httpRequestParser');
+        if (parser) {
+            return parser;
+        }
+
         if (this.bodyValidation) {
             assertType(this.parameter.type, ReflectionKind.class);
             const valueType = findMember('value', this.parameter.type.types);
@@ -101,22 +118,22 @@ export class ParameterForRequestParser {
     }
 
     get header() {
-        return metaAnnotation.getForName(this.parameter.type, 'httpHeader') !== undefined;
+        return typeAnnotation.getType(this.parameter.type, 'httpHeader') !== undefined;
     }
 
     get query() {
-        return metaAnnotation.getForName(this.parameter.type, 'httpQuery') !== undefined;
+        return typeAnnotation.getType(this.parameter.type, 'httpQuery') !== undefined;
     }
 
     get queries() {
-        return metaAnnotation.getForName(this.parameter.type, 'httpQueries') !== undefined;
+        return typeAnnotation.getType(this.parameter.type, 'httpQueries') !== undefined;
     }
 
     get typePath(): string | undefined {
-        const typeOptions = metaAnnotation.getForName(this.parameter.type, 'httpQueries') || metaAnnotation.getForName(this.parameter.type, 'httpQuery')
-            || metaAnnotation.getForName(this.parameter.type, 'httpPath') || metaAnnotation.getForName(this.parameter.type, 'httpHeader');
+        const typeOptions = typeAnnotation.getType(this.parameter.type, 'httpQueries') || typeAnnotation.getType(this.parameter.type, 'httpQuery')
+            || typeAnnotation.getType(this.parameter.type, 'httpPath') || typeAnnotation.getType(this.parameter.type, 'httpHeader');
         if (!typeOptions) return;
-        const options = typeToObject(typeOptions[0]);
+        const options = typeToObject(typeOptions);
         if (isObject(options)) return options.name;
         return;
     }
@@ -126,7 +143,7 @@ export class ParameterForRequestParser {
     }
 
     isPartOfPath(): boolean {
-        return metaAnnotation.getForName(this.parameter.type, 'httpPath') !== undefined || this.regexPosition !== undefined;
+        return typeAnnotation.getType(this.parameter.type, 'httpPath') !== undefined || this.regexPosition !== undefined;
     }
 }
 
@@ -152,26 +169,38 @@ export function parseRoutePathToRegex(path: string, params: ReflectionParameter[
     return { regex: path, parameterNames };
 }
 
-export function buildRequestParser(parseOptions: HttpParserOptions, parameters: ReflectionParameter[], path?: string): (request: HttpRequest) => any[] {
+function isTypeUnknown(type: Type): boolean {
+    if (type.id) return false; //if is has an id we treat it as nominal type
+    return type.kind === ReflectionKind.unknown || type.kind === ReflectionKind.any
+        || type.kind === ReflectionKind.never;
+}
+
+export function buildRequestParser(parseOptions: HttpParserOptions, parameters: ReflectionParameter[], routeConfig?: RouteConfig): (request: HttpRequest) => any[] {
     const compiler = new CompilerContext();
     const params = parameters.map(v => new ParameterForRequestParser(v));
 
     //todo: parse path
     let pathRegex = '';
-    if (path) {
-        const parsedPath = parseRoutePathToRegex(path, parameters);
+    let pathParameterNames: { [name: string]: number } = {};
+
+    if (routeConfig) {
+        const parsedPath = parseRoutePathToRegex(routeConfig.getFullPath(), parameters);
         pathRegex = parsedPath.regex;
+        pathParameterNames = parsedPath.parameterNames;
 
         for (const param of params) {
             param.regexPosition = parsedPath.parameterNames[param.parameter.name];
         }
     }
 
-    const code = getRequestParserCodeForParameters(compiler, parseOptions, params, {});
+    const code = getRequestParserCodeForParameters(compiler, parseOptions, params, {
+        pathParameterNames,
+        routeConfig
+    });
     compiler.context.set('ValidationError', ValidationError);
     compiler.context.set('qs', qs);
 
-    let needsQueryString = !!params.find(v => v.query || v.queries);
+    let needsQueryString = !!params.find(v => v.query || v.queries || v.requestParser);
     const query = needsQueryString ? '_qPosition === -1 ? {} : qs.parse(_url.substr(_qPosition + 1))' : '{}';
 
     const regexVar = compiler.reserveVariable('regex', new RegExp('^' + pathRegex + '$'));
@@ -199,8 +228,9 @@ export function getRequestParserCodeForParameters(
         resolverForToken?: Map<any, ClassType>,
         pathParameterNames?: { [name: string]: number },
         routeConfig?: RouteConfig,
-    }
+    },
 ) {
+    compiler.set({ DependenciesUnmetError });
     let enableParseBody = false;
     let requiresAsyncParameters = false;
     const setParameters: string[] = [];
@@ -210,14 +240,11 @@ export function getRequestParserCodeForParameters(
     let bodyValidationErrorHandling = `if (bodyErrors.length) throw ValidationError.from(bodyErrors);`;
 
     for (const parameter of parameters) {
-        if (parameter.body || parameter.bodyValidation) {
+        if (parameter.requestParser || parameter.body || parameter.bodyValidation) {
             const type = parameter.getType();
             const validatorVar = compiler.reserveVariable('argumentValidator', getValidatorFunction(undefined, type));
             const converterVar = compiler.reserveVariable('argumentConverter', getSerializeFunction(type, serializer.deserializeRegistry));
 
-            enableParseBody = true;
-            setParameters.push(`parameters.${parameter.parameter.name} = ${converterVar}(bodyFields, {loosely: true});`);
-            parameterValidator.push(`${validatorVar}(parameters.${parameter.parameter.name}, {errors: bodyErrors});`);
             if (parameter.bodyValidation) {
                 compiler.context.set('BodyValidation', ValidatedBody);
                 compiler.context.set('BodyValidationError', BodyValidationError);
@@ -226,9 +253,44 @@ export function getRequestParserCodeForParameters(
             } else {
                 parameterNames.push(`parameters.${parameter.parameter.name}`);
             }
+
+            if (parameter.requestParser) {
+                const parseOptionsVar = compiler.reserveVariable('parseOptions', parseOptions);
+                const parseBodyVar = compiler.reserveVariable('parseBody', parseBody);
+
+                let assignPathNames: string[] = [];
+                for (const [name, index] of Object.entries(config.pathParameterNames || {})) {
+                    assignPathNames.push(`res.${name} = _match[${1 + index}];`);
+                }
+
+                setParameters.push(`parameters.${parameter.parameter.name} = async (options = {}) => {
+                    let res = {};
+                    if (options.withPath !== false) {
+                        ${assignPathNames.join('\n')}
+                    }
+                    if (options.withHeader !== false) {
+                        Object.assign(res, _headers);
+                    }
+                    if (options.withBody !== false) {
+                        bodyFields = bodyFields || (await ${parseBodyVar}(${parseOptionsVar}, request, uploadedFiles));
+                        Object.assign(res, bodyFields);
+                    }
+                    if (options.withQuery !== false) {
+                        Object.assign(res, _query);
+                    }
+                    res = ${converterVar}(res, {loosely: true});
+                    ${validatorVar}(res, {errors: bodyErrors});
+                    if (bodyErrors.length) throw ValidationError.from(bodyErrors);
+                    return res;
+                }`);
+            } else {
+                enableParseBody = true;
+                setParameters.push(`parameters.${parameter.parameter.name} = ${converterVar}(bodyFields, {loosely: true});`);
+                parameterValidator.push(`${validatorVar}(parameters.${parameter.parameter.name}, {errors: bodyErrors});`);
+            }
         } else if (parameter.query || parameter.queries || parameter.header) {
             const converted = getSerializeFunction(parameter.parameter.parameter, serializer.deserializeRegistry, undefined, parameter.getName());
-            const validator = getValidatorFunction(undefined, parameter.parameter.parameter,);
+            const validator = getValidatorFunction(undefined, parameter.parameter.parameter);
             const converterVar = compiler.reserveVariable('argumentConverter', converted);
             const validatorVar = compiler.reserveVariable('argumentValidator', validator);
 
@@ -236,7 +298,12 @@ export function getRequestParserCodeForParameters(
             const accessor = queryPath ? `['` + (queryPath.replace(/\./g, `']['`)) + `']` : '';
             const queryAccessor = parameter.header ? `_headers${accessor}` : queryPath ? `_query${accessor}` : '_query';
 
-            setParameters.push(`parameters.${parameter.parameter.name} = ${converterVar}(${queryAccessor}, {loosely: true});`);
+            if (isOptional(parameter.parameter.parameter) || hasDefaultValue(parameter.parameter.parameter)) {
+                setParameters.push(`parameters.${parameter.parameter.name} = ${queryAccessor} === undefined ? undefined : ${converterVar}(${queryAccessor}, {loosely: true});`);
+            } else {
+                setParameters.push(`parameters.${parameter.parameter.name} = ${converterVar}(${queryAccessor}, {loosely: true});`);
+            }
+
             parameterNames.push(`parameters.${parameter.parameter.name}`);
             parameterValidator.push(`${validatorVar}(parameters.${parameter.parameter.name}, {errors: validationErrors}, ${JSON.stringify(parameter.typePath || parameter.getName())});`);
         } else {
@@ -256,13 +323,13 @@ export function getRequestParserCodeForParameters(
                 }
             }
 
-            const injectorToken = parameter.parameter.type.kind === ReflectionKind.class ? parameter.parameter.type.classType : undefined;
-            const injectorTokenVar = compiler.reserveVariable('classType', injectorToken);
+            const injectorTokenVar = compiler.reserveVariable('type', parameter.parameter.type);
             const parameterResolverFoundVar = compiler.reserveVariable('parameterResolverFound', false);
 
             setParameters.push(`${parameterResolverFoundVar} = false;`);
 
-            const resolverType = config.resolverForParameterName?.get(parameter.getName()) || config.resolverForToken?.get(injectorToken);
+            const resolverType = config.resolverForParameterName?.get(parameter.getName())
+                || config.resolverForToken?.get(parameter.parameter.type.kind === ReflectionKind.class ? parameter.parameter.type.classType : undefined);
 
             //make sure all parameter values from the path are available, important for parameter resolver
             if (resolverType && !setParametersFromPath && config.pathParameterNames) {
@@ -271,8 +338,14 @@ export function getRequestParserCodeForParameters(
                 }
             }
 
+            if (!resolverType && !parameter.isPartOfPath() && isTypeUnknown(parameter.parameter.type)) {
+                const label = config.routeConfig ? getRouteActionLabel(config.routeConfig?.action) + ' ' : '';
+                throw new Error(`Parameter ${label}${JSON.stringify(parameter.parameter.name)} has no runtime type. Runtime types disabled or circular dependencies?`);
+            }
+
             let injector = '_injector';
-            const moduleVar = config.module ? ', ' + compiler.reserveConst(config.module, 'module') : '';
+            const moduleRawVar = config.module ? compiler.reserveConst(config.module, 'module') : 'undefined';
+            const moduleVar = config.module ? `, ${moduleRawVar}` : '';
 
             if (resolverType) {
                 requiresAsyncParameters = true;
@@ -287,13 +360,15 @@ export function getRequestParserCodeForParameters(
                 const instance = compiler.reserveVariable('resolverInstance');
 
                 const routeConfigVar = compiler.reserveVariable('routeConfigVar', config.routeConfig);
+                const classTypeToken = parameter.parameter.type.kind === ReflectionKind.class ? parameter.parameter.type.classType : undefined;
+                const classTypeTokenVar = compiler.reserveVariable('classType', classTypeToken);
                 setParameters.push(`
                     //resolver ${getClassName(resolverType)} for ${parameter.getName()}
                     ${instance} = ${instanceFetcher};
                     if (!${parameterResolverFoundVar}) {
                         ${parameterResolverFoundVar} = true;
                         parameters.${parameter.parameter.name} = await ${instance}.resolve({
-                            token: ${injectorTokenVar},
+                            token: ${classTypeTokenVar},
                             route: ${routeConfigVar},
                             request: request,
                             name: ${JSON.stringify(parameter.parameter.name)},
@@ -306,11 +381,20 @@ export function getRequestParserCodeForParameters(
             }
 
             if (!parameter.isPartOfPath()) {
-                let injectorGet = `parameters.${parameter.parameter.name} = ${injector}.get(${injectorTokenVar});`;
-                if (parameter.parameter.isOptional()) {
-                    injectorGet = `try {parameters.${parameter.parameter.name} = ${injector}.get(${injectorTokenVar}); } catch (e) {}`;
+                const resolverVar = compiler.reserveVariable('resolver');
+                let injectorGet = `
+                if (!${resolverVar}) ${resolverVar} = ${injector}.resolve(${moduleRawVar}, ${injectorTokenVar});
+                parameters.${parameter.parameter.name} = ${resolverVar}(${injector}.scope);
+                `;
+                if (!parameter.parameter.isOptional()) {
+                    injectorGet += `
+                    if (!parameters.${parameter.parameter.name}) {
+                        throw new DependenciesUnmetError(
+                            \`Parameter \${${JSON.stringify(parameter.parameter.name)}} is required but provider returned undefined.\`,
+                        );
+                    }`;
                 }
-                setParameters.push(`if (!${parameterResolverFoundVar}) ${injectorGet}`);
+                setParameters.push(`if (!${parameterResolverFoundVar}) { ${injectorGet} }`);
             }
         }
     }
@@ -321,7 +405,7 @@ export function getRequestParserCodeForParameters(
         const parseOptionsVar = compiler.reserveVariable('parseOptions', parseOptions);
         const parseBodyVar = compiler.reserveVariable('parseBody', parseBody);
         parseBodyLoading = `
-            const bodyFields = (await ${parseBodyVar}(${parseOptionsVar}, request, uploadedFiles));`;
+            bodyFields = bodyFields || (await ${parseBodyVar}(${parseOptionsVar}, request, uploadedFiles));`;
         requiresAsyncParameters = true;
     }
 
@@ -332,6 +416,7 @@ export function getRequestParserCodeForParameters(
                 const validationErrors = [];
                 const bodyErrors = [];
                 const parameters = {};
+                let bodyFields;
                 ${setParametersFromPath}
                 ${parseBodyLoading}
                 ${setParameters.join('\n')}

package/src/router.ts

@@ -8,10 +8,21 @@
  * You should have received a copy of the MIT License along with this program.
  */
 import { ClassType, CompilerContext, getClassName, isArray, isClass, urlJoin } from '@deepkit/core';
-import { entity, ReflectionClass, ReflectionFunction, ReflectionKind, ReflectionParameter, SerializationOptions, Serializer, Type, ValidationError } from '@deepkit/type';
-import { HttpAction, httpClass, HttpController, HttpDecorator } from './decorator.js';
+import {
+    entity,
+    ReflectionClass,
+    ReflectionFunction,
+    ReflectionKind,
+    ReflectionParameter,
+    SerializationOptions,
+    serializer,
+    Serializer,
+    Type,
+    ValidationError,
+} from '@deepkit/type';
+import { getActions, HttpAction, httpClass, HttpController, HttpDecorator } from './decorator.js';
 import { HttpRequest, HttpRequestPositionedParameters, HttpRequestQuery, HttpRequestResolvedParameters } from './model.js';
-import { InjectorContext, InjectorModule, TagRegistry } from '@deepkit/injector';
+import { InjectorContext, InjectorModule } from '@deepkit/injector';
 import { Logger, LoggerInterface } from '@deepkit/logger';
 import { HttpControllers } from './controllers.js';
 import { MiddlewareRegistry, MiddlewareRegistryEntry } from '@deepkit/app';
@@ -21,7 +32,7 @@ import { HttpMiddlewareConfig, HttpMiddlewareFn } from './middleware.js';
 import qs from 'qs';
 import { HtmlResponse, JSONResponse, Response } from './http.js';
 import { getRequestParserCodeForParameters, ParameterForRequestParser, parseRoutePathToRegex } from './request-parser.js';
-import { HttpConfig, HttpParserOptions } from './module.config.js';
+import { HttpConfig } from './module.config.js';
 
 export type RouteParameterResolverForInjector = ((injector: InjectorContext) => HttpRequestPositionedParameters | Promise<HttpRequestPositionedParameters>);
 
@@ -29,11 +40,18 @@ interface ResolvedController {
     parameters: RouteParameterResolverForInjector;
     routeConfig: RouteConfig;
     uploadedFiles: { [name: string]: UploadedFile };
-    middlewares?: (injector: InjectorContext) => { fn: HttpMiddlewareFn, timeout: number }[];
+    middlewares?: (injector: InjectorContext) => { fn: HttpMiddlewareFn, timeout?: number }[];
 }
 
+export const UploadedFileSymbol = Symbol('UploadedFile');
+
 @entity.name('@deepkit/UploadedFile')
 export class UploadedFile {
+    /**
+     * Validator to ensure the file was provided by the framework, and not the user spoofing it.
+     */
+    validator!: typeof UploadedFileSymbol | null;
+
     /**
      * The size of the uploaded file in bytes.
      */
@@ -66,6 +84,11 @@ export class UploadedFile {
     // hash!: string | 'sha1' | 'md5' | 'sha256' | null;
 }
 
+serializer.typeGuards.getRegistry(1).registerClass(UploadedFile, (type, state) => {
+    state.setContext({ UploadedFileSymbol });
+    state.addSetterAndReportErrorIfInvalid('uploadSecurity', 'Not an uploaded file', `typeof ${state.accessor} === 'object' && ${state.accessor} !== null && ${state.accessor}.validator === UploadedFileSymbol`);
+});
+
 export interface RouteFunctionControllerAction {
     type: 'function';
     //if not set, the root module is used
@@ -81,6 +104,11 @@ export interface RouteClassControllerAction {
     methodName: string;
 }
 
+export function getRouteActionLabel(action: RouteClassControllerAction | RouteFunctionControllerAction): string {
+    if (action.type === 'controller') return `${getClassName(action.controller)}.${action.methodName}`;
+    return action.fn.name;
+}
+
 export class RouteConfig {
     public baseUrl: string = '';
 
@@ -141,7 +169,7 @@ export class RouteConfig {
     }
 }
 
-class ParsedRoute {
+export class ParsedRoute {
     public regex?: string;
 
     public pathParameterNames: { [name: string]: number } = {};
@@ -503,7 +531,7 @@ export class HttpRouterRegistry extends HttpRouterRegistryFunctionRegistrar {
         if (!controllerData) throw new Error(`Http controller class ${getClassName(controller)} has no @http.controller decorator.`);
         const schema = ReflectionClass.from(controller);
 
-        for (const action of controllerData.getActions()) {
+        for (const action of getActions(controller)) {
             const routeAction: RouteClassControllerAction = {
                 type: 'controller',
                 controller,
@@ -533,7 +561,6 @@ export class HttpRouter {
     constructor(
         controllers: HttpControllers,
         private logger: LoggerInterface,
-        tagRegistry: TagRegistry,
         private config: HttpConfig,
         private middlewareRegistry: MiddlewareRegistry = new MiddlewareRegistry,
         private registry: HttpRouterRegistry = new HttpRouterRegistry,
@@ -549,14 +576,13 @@ export class HttpRouter {
 
     static forControllers(
         controllers: (ClassType | { module: InjectorModule<any>, controller: ClassType })[],
-        tagRegistry: TagRegistry = new TagRegistry(),
         middlewareRegistry: MiddlewareRegistry = new MiddlewareRegistry(),
         module: InjectorModule<any> = new InjectorModule(),
         config: HttpConfig = new HttpConfig()
     ): HttpRouter {
         return new this(new HttpControllers(controllers.map(v => {
             return isClass(v) ? { controller: v, module } : v;
-        })), new Logger([], []), tagRegistry, config, middlewareRegistry);
+        })), new Logger([], []), config, middlewareRegistry);
     }
 
     protected getRouteCode(compiler: CompilerContext, routeConfig: RouteConfig): string {

package/src/static-serving.ts

@@ -18,44 +18,55 @@ import { ClassType, urlJoin } from '@deepkit/core';
 import { HttpRequest, HttpResponse } from './model.js';
 import send from 'send';
 import { eventDispatcher } from '@deepkit/event';
-import { RouteConfig, HttpRouter } from './router.js';
+import { HttpRouter, RouteConfig } from './router.js';
+
+export function staticServe(
+    localPath: string,
+    path: string,
+    request: HttpRequest,
+    response: HttpResponse,
+) {
+    return new Promise((resolve, reject) => {
+        const res = send(request, path, { root: localPath });
+        res.pipe(response);
+        res.on('end', resolve);
+    });
+}
+
+export async function staticOnRoute(
+    event: typeof httpWorkflow.onRoute.event,
+    path: string,
+    localPath: string,
+) {
+    if (event.sent) return;
+    if (event.route) return;
+
+    if (!event.request.url?.startsWith(path)) return;
+
+    const relativePath = urlJoin('/', event.url.substr(path.length));
+    const finalLocalPath = join(localPath, relativePath);
+
+    return new Promise(resolve => {
+        stat(finalLocalPath, (err, stat) => {
+            if (stat && stat.isFile()) {
+                event.routeFound(
+                    new RouteConfig('static', ['GET'], event.url, {
+                        type: 'function',
+                        fn: staticServe,
+                    }),
+                    () => ({ arguments: [localPath, relativePath, event.request, event.response], parameters: {} }),
+                );
+            }
+            resolve(undefined);
+        });
+    });
+}
 
 export function serveStaticListener(module: AppModule<any>, path: string, localPath: string = path): ClassType {
     class HttpRequestStaticServingListener {
-        serve(path: string, request: HttpRequest, response: HttpResponse) {
-            return new Promise((resolve, reject) => {
-                const res = send(request, path, { root: localPath });
-                res.pipe(response);
-                res.on('end', resolve);
-            });
-        }
-
         @eventDispatcher.listen(httpWorkflow.onRoute, 101) //after default route listener at 100
         onRoute(event: typeof httpWorkflow.onRoute.event) {
-            if (event.sent) return;
-            if (event.route) return;
-
-            if (!event.request.url?.startsWith(path)) return;
-
-            const relativePath = urlJoin('/', event.url.substr(path.length));
-            const finalLocalPath = join(localPath, relativePath);
-
-            return new Promise(resolve => {
-                stat(finalLocalPath, (err, stat) => {
-                    if (stat && stat.isFile()) {
-                        event.routeFound(
-                            new RouteConfig('static', ['GET'], event.url, {
-                                type: 'controller',
-                                controller: HttpRequestStaticServingListener,
-                                module,
-                                methodName: 'serve'
-                            }),
-                            () => ({arguments: [relativePath, event.request, event.response], parameters: {}})
-                        );
-                    }
-                    resolve(undefined);
-                });
-            });
+            return staticOnRoute(event, path, localPath);
         }
     }
 
@@ -108,7 +119,7 @@ export function registerStaticHttpController(module: AppModule<any>, options: St
     const groups = options.groups || [];
 
     class StaticController {
-        @http.GET().group(...groups)
+        @(http.GET().group(...groups))
         serveIndex(request: HttpRequest, response: HttpResponse) {
             if (!indexHtml) {
                 indexHtml = loadHtml(options.localPath, normalizeDirectory(options.path));
@@ -132,20 +143,20 @@ export function registerStaticHttpController(module: AppModule<any>, options: St
         type: 'controller',
         controller: StaticController,
         module,
-        methodName: 'serveIndex'
+        methodName: 'serveIndex',
     });
     route1.groups = groups;
-    module.setupGlobalProvider<HttpRouter>().addRoute(route1);
+    module.configureProvider<HttpRouter>(router => router.addRoute(route1), { global: true });
 
     if (path !== '/') {
         const route2 = new RouteConfig('static', ['GET'], path.slice(0, -1), {
             type: 'controller',
             controller: StaticController,
             module,
-            methodName: 'serveIndex'
+            methodName: 'serveIndex',
         });
         route2.groups = groups;
-        module.setupGlobalProvider<HttpRouter>().addRoute(route2);
+        module.configureProvider<HttpRouter>(router => router.addRoute(route2), { global: true });
     }
 
     module.addProvider(StaticController);

package/tsconfig.json

@@ -8,19 +8,25 @@
     "experimentalDecorators": true,
     "emitDecoratorMetadata": true,
     "moduleResolution": "node",
-    "target": "es2018",
+    "target": "es2020",
     "module": "CommonJS",
     "esModuleInterop": true,
     "outDir": "./dist/cjs",
     "declaration": true,
-    "composite": true
+    "composite": true,
+    "types": [
+      "node",
+      "send"
+    ]
   },
   "reflection": true,
   "include": [
     "src",
-    "tests",
     "index.ts"
   ],
+  "exclude": [
+    "tests"
+  ],
   "references": [
     {
       "path": "../app/tsconfig.json"

package/tsconfig.spec.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.json",
+  "include": [
+    "src",
+    "index.ts",
+    "tests"
+  ]
+}