@deepkit/http 1.0.1-alpha.100

package/src/module.ts

@@ -0,0 +1,116 @@
+import { HttpListener, HttpResultFormatter, httpWorkflow } from './http.js';
+import { HttpConfig } from './module.config.js';
+import { AddedListener, AppModule, ControllerConfig, createModule, stringifyListener } from '@deepkit/app';
+import { HttpRouter, HttpRouterRegistry, RouteConfig } from './router.js';
+import { HttpKernel } from './kernel.js';
+import { HttpRouterFilterResolver } from './filter.js';
+import { HttpControllers } from './controllers.js';
+import { ConsoleTransport, Logger } from '@deepkit/logger';
+import { HttpRequest, HttpResponse } from './model.js';
+import '@deepkit/type';
+import { httpClass } from './decorator.js';
+import { EventToken } from '@deepkit/event';
+import { metaAnnotation, ReflectionKind, ReflectionParameter, Type } from '@deepkit/type';
+import { buildRequestParser } from './request-parser.js';
+import { InjectorContext } from '@deepkit/injector';
+
+function parameterRequiresRequest(parameter: ReflectionParameter): boolean {
+    return Boolean(metaAnnotation.getForName(parameter.type, 'httpQueries') || metaAnnotation.getForName(parameter.type, 'httpQuery')
+        || metaAnnotation.getForName(parameter.type, 'httpBody') || metaAnnotation.getForName(parameter.type, 'httpPath') || metaAnnotation.getForName(parameter.type, 'httpHeader'));
+}
+
+export class HttpModule extends createModule({
+    config: HttpConfig,
+    providers: [
+        HttpRouter,
+        HttpKernel,
+        HttpResultFormatter,
+        HttpRouterRegistry,
+        HttpRouterFilterResolver,
+        { provide: HttpResponse, scope: 'http' },
+        { provide: HttpRequest, scope: 'http' },
+        { provide: RouteConfig, useValue: undefined, scope: 'http' },
+        { provide: Logger, useValue: new Logger([new ConsoleTransport()]) },
+    ],
+    listeners: [
+        HttpListener,
+    ],
+    workflows: [
+        httpWorkflow
+    ],
+    exports: [
+        HttpRouter,
+        HttpRouterRegistry,
+        HttpKernel,
+        HttpResultFormatter,
+        HttpRouterFilterResolver,
+        HttpResponse,
+        HttpRequest,
+        HttpControllers,
+        RouteConfig,
+        Logger,
+    ]
+}) {
+    protected httpControllers = new HttpControllers;
+
+    process() {
+        this.addProvider({ provide: HttpControllers, useValue: this.httpControllers });
+    }
+
+    protected patchEventsForHttpRequestAccess: EventToken<any>[] = [httpWorkflow.onRequest, httpWorkflow.onAuth, httpWorkflow.onController];
+
+    processListener(module: AppModule<any>, listener: AddedListener) {
+        if (!this.patchEventsForHttpRequestAccess.includes(listener.eventToken)) return;
+
+        let requiresHttpRequest = false;
+        let needsAsync = false;
+        const params = listener.reflection.getParameters().slice(1);
+
+        for (const parameter of params) {
+            if (metaAnnotation.getForName(parameter.type, 'httpBody')) needsAsync = true;
+            if (parameterRequiresRequest(parameter)) requiresHttpRequest = true;
+        }
+
+        if (needsAsync) {
+            //not yet supported since we have to patch the listener to be async and redirect the call (as the DI container is sync).
+            throw new Error(`Listener ${stringifyListener(listener)} requires async HttpBody. This is not yet supported. You have to parse the request manually by injecting HttpRequest.`);
+        }
+
+        for (let index = 0; index < params.length; index++) {
+            const parameter = params[index];
+            if (!parameterRequiresRequest(parameter)) continue;
+
+            //change the reflection type so that we create a unique injection token for that type.
+            const unique = Symbol('unique');
+            const uniqueType: Type = { kind: ReflectionKind.literal, literal: unique };
+            metaAnnotation.registerType(parameter.type, { name: 'inject', options: [uniqueType] });
+            let build: Function;
+            let i = index;
+
+            this.addProvider({
+                provide: uniqueType, useFactory: (httpConfig: HttpConfig, request: HttpRequest, injector: InjectorContext, config?: RouteConfig) => {
+                    if (!build) {
+                        const params = listener.reflection.getParameters().slice(1);
+                        build = buildRequestParser(httpConfig.parser, params, config?.getFullPath());
+                    }
+
+                    const parser = build(request);
+                    const params = parser(injector);
+                    return params.arguments[i];
+                }, scope: 'http'
+            });
+            this.addExport(uniqueType);
+        }
+    }
+
+    processController(module: AppModule<any>, config: ControllerConfig) {
+        const controller = config.controller;
+        if (!controller) return;
+
+        const httpConfig = httpClass._fetch(controller);
+        if (!httpConfig) return;
+
+        if (!module.isProvided(controller)) module.addProvider({ provide: controller, scope: 'http' });
+        this.httpControllers.add(controller, module);
+    }
+}

package/src/request-parser.ts

@@ -0,0 +1,346 @@
+import { asyncOperation, ClassType, CompilerContext, getClassName, isObject } from '@deepkit/core';
+import { InjectorModule } from '@deepkit/injector';
+import {
+    assertType,
+    findMember,
+    getSerializeFunction,
+    getValidatorFunction,
+    metaAnnotation,
+    ReflectionKind,
+    ReflectionParameter,
+    resolveReceiveType,
+    serializer,
+    stringifyType,
+    Type,
+    typeToObject,
+    ValidationError
+} from '@deepkit/type';
+import { BodyValidationError, createRequestWithCachedBody, getRegExp, HttpRequest, ValidatedBody } from './model.js';
+import { RouteConfig, UploadedFile, UploadedFileSymbol } from './router.js';
+
+//@ts-ignore
+import qs from 'qs';
+
+// @ts-ignore
+import formidable from 'formidable';
+import { HttpParserOptions } from './module.config.js';
+
+
+function parseBody(
+    options: HttpParserOptions,
+    req: HttpRequest, foundFiles: { [name: string]: UploadedFile }) {
+    const form = formidable(Object.assign(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] = {
+                        validator: UploadedFileSymbol,
+                        size: file.size,
+                        path: file.filepath,
+                        name: file.originalFilename,
+                        type: file.mimetype,
+                        lastModifiedDate: file.lastModifiedDate,
+                    };
+                }
+                const body = { ...fields, ...foundFiles };
+                resolve(body);
+            }
+        }
+
+        if (req.body) {
+            form.parse(createRequestWithCachedBody(req, req.body), parseData);
+            return;
+        }
+
+        const chunks: Buffer[] = [];
+
+        function read(chunk: Buffer) {
+            chunks.push(chunk);
+        }
+
+        req.on('data', read);
+        req.once('end', () => {
+            req.body = Buffer.concat(chunks);
+            req.off('data', read);
+        });
+        req.once('error', () => req.off('data', read));
+
+        form.parse(req, parseData);
+    });
+}
+
+export class ParameterForRequestParser {
+    regexPosition?: number;
+
+    constructor(
+        public parameter: ReflectionParameter,
+    ) {
+    }
+
+    get body() {
+        return metaAnnotation.getForName(this.parameter.type, 'httpBody') !== undefined;
+    }
+
+    get bodyValidation() {
+        return metaAnnotation.getForName(this.parameter.type, 'httpBodyValidation') !== undefined;
+    }
+
+    getType(): Type {
+        if (this.bodyValidation) {
+            assertType(this.parameter.type, ReflectionKind.class);
+            const valueType = findMember('value', this.parameter.type.types);
+            if (!valueType || valueType.kind !== ReflectionKind.property) throw new Error(`No property value found at ${stringifyType(this.parameter.type)}`);
+            return valueType.type as Type;
+        }
+        return this.parameter.type;
+    }
+
+    get header() {
+        return metaAnnotation.getForName(this.parameter.type, 'httpHeader') !== undefined;
+    }
+
+    get query() {
+        return metaAnnotation.getForName(this.parameter.type, 'httpQuery') !== undefined;
+    }
+
+    get queries() {
+        return metaAnnotation.getForName(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');
+        if (!typeOptions) return;
+        const options = typeToObject(typeOptions[0]);
+        if (isObject(options)) return options.name;
+        return;
+    }
+
+    getName() {
+        return this.parameter.name;
+    }
+
+    isPartOfPath(): boolean {
+        return metaAnnotation.getForName(this.parameter.type, 'httpPath') !== undefined || this.regexPosition !== undefined;
+    }
+}
+
+export function parseRoutePathToRegex(path: string, params: ReflectionParameter[]): { regex: string, parameterNames: { [name: string]: number } } {
+    const parameterNames: { [name: string]: number } = {};
+
+    let argumentIndex = 0;
+    path = path.replace(/:(\w+)/g, (a, name) => {
+        parameterNames[name] = argumentIndex;
+        argumentIndex++;
+        const parameter = params.find(v => v.name === name);
+        if (parameter) {
+            const regExp = getRegExp(parameter.type);
+            if (regExp instanceof RegExp) {
+                return '(' + regExp.source + ')';
+            } else if (regExp) {
+                return '(' + regExp + ')';
+            }
+        }
+        return String.raw`([^/]+)`;
+    });
+
+    return { regex: path, parameterNames };
+}
+
+export function buildRequestParser(parseOptions: HttpParserOptions, parameters: ReflectionParameter[], path?: string): (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);
+        pathRegex = parsedPath.regex;
+
+        for (const param of params) {
+            param.regexPosition = parsedPath.parameterNames[param.parameter.name];
+        }
+    }
+
+    const code = getRequestParserCodeForParameters(compiler, parseOptions, params, {});
+    compiler.context.set('ValidationError', ValidationError);
+    compiler.context.set('qs', qs);
+
+    let needsQueryString = !!params.find(v => v.query || v.queries);
+    const query = needsQueryString ? '_qPosition === -1 ? {} : qs.parse(_url.substr(_qPosition + 1))' : '{}';
+
+    const regexVar = compiler.reserveVariable('regex', new RegExp('^' + pathRegex + '$'));
+
+    return compiler.build(`
+        const _method = request.method || 'GET';
+        const _url = request.url || '/';
+        const _headers = request.headers || {};
+        const _qPosition = _url.indexOf('?');
+        let uploadedFiles = {};
+        const _path = _qPosition === -1 ? _url : _url.substr(0, _qPosition);
+        const _match = _path.match(${regexVar}) || [];
+        const _query = ${query};
+        return ${code}
+    `, 'request');
+}
+
+export function getRequestParserCodeForParameters(
+    compiler: CompilerContext,
+    parseOptions: HttpParserOptions,
+    parameters: ParameterForRequestParser[],
+    config: {
+        module?: InjectorModule<any>,
+        resolverForParameterName?: Map<string, ClassType>,
+        resolverForToken?: Map<any, ClassType>,
+        pathParameterNames?: { [name: string]: number },
+        routeConfig?: RouteConfig,
+    }
+) {
+    let enableParseBody = false;
+    let requiresAsyncParameters = false;
+    const setParameters: string[] = [];
+    const parameterNames: string[] = [];
+    const parameterValidator: string[] = [];
+    let setParametersFromPath = '';
+    let bodyValidationErrorHandling = `if (bodyErrors.length) throw ValidationError.from(bodyErrors);`;
+
+    for (const parameter of parameters) {
+        if (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);
+                parameterNames.push(`new BodyValidation(new BodyValidationError(bodyErrors), bodyErrors.length === 0 ? parameters.${parameter.parameter.name} : undefined)`);
+                bodyValidationErrorHandling = '';
+            } else {
+                parameterNames.push(`parameters.${parameter.parameter.name}`);
+            }
+        } 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 converterVar = compiler.reserveVariable('argumentConverter', converted);
+            const validatorVar = compiler.reserveVariable('argumentValidator', validator);
+
+            const queryPath = parameter.typePath === undefined && !parameter.queries ? parameter.parameter.name : parameter.typePath;
+            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});`);
+            parameterNames.push(`parameters.${parameter.parameter.name}`);
+            parameterValidator.push(`${validatorVar}(parameters.${parameter.parameter.name}, {errors: validationErrors}, ${JSON.stringify(parameter.typePath || parameter.getName())});`);
+        } else {
+            parameterNames.push(`parameters.${parameter.parameter.name}`);
+
+            if (parameter.isPartOfPath()) {
+                if (parameter.parameter.type.kind !== ReflectionKind.class) {
+                    const converted = getSerializeFunction(parameter.parameter.parameter, serializer.deserializeRegistry, undefined, parameter.getName());
+                    const converterVar = compiler.reserveVariable('argumentConverter', converted);
+                    setParameters.push(`parameters.${parameter.parameter.name} = ${converterVar}(_match[${1 + (parameter.regexPosition || 0)}], {loosely: true});`);
+
+                    const validator = getValidatorFunction(undefined, parameter.parameter.parameter);
+                    const validatorVar = compiler.reserveVariable('argumentValidator', validator);
+                    parameterValidator.push(`${validatorVar}(parameters.${parameter.parameter.name}, {errors: validationErrors}, ${JSON.stringify(parameter.getName())});`);
+                } else {
+                    setParameters.push(`parameters.${parameter.parameter.name} = _match[${1 + (parameter.regexPosition || 0)}];`);
+                }
+            }
+
+            const injectorToken = parameter.parameter.type.kind === ReflectionKind.class ? parameter.parameter.type.classType : undefined;
+            const injectorTokenVar = compiler.reserveVariable('classType', injectorToken);
+            const parameterResolverFoundVar = compiler.reserveVariable('parameterResolverFound', false);
+
+            setParameters.push(`${parameterResolverFoundVar} = false;`);
+
+            const resolverType = config.resolverForParameterName?.get(parameter.getName()) || config.resolverForToken?.get(injectorToken);
+
+            //make sure all parameter values from the path are available, important for parameter resolver
+            if (resolverType && !setParametersFromPath && config.pathParameterNames) {
+                for (const i in config.pathParameterNames) {
+                    setParametersFromPath += `parameters.${i} = _match[${1 + config.pathParameterNames[i]}];`;
+                }
+            }
+
+            let injector = '_injector';
+            const moduleVar = config.module ? ', ' + compiler.reserveConst(config.module, 'module') : '';
+
+            if (resolverType) {
+                requiresAsyncParameters = true;
+                let instanceFetcher = '';
+                if (config.module && config.module.injector) {
+                    const resolverResolverVar = compiler.reserveVariable('resolverProvideToken', config.module.injector.createResolver(resolveReceiveType(resolverType)));
+                    instanceFetcher = `${resolverResolverVar}(${injector}.scope)`;
+                } else {
+                    const resolverProvideTokenVar = compiler.reserveVariable('resolverProvideToken', resolverType);
+                    instanceFetcher = `${injector}.get(${resolverProvideTokenVar}${moduleVar})`;
+                }
+                const instance = compiler.reserveVariable('resolverInstance');
+
+                const routeConfigVar = compiler.reserveVariable('routeConfigVar', config.routeConfig);
+                setParameters.push(`
+                    //resolver ${getClassName(resolverType)} for ${parameter.getName()}
+                    ${instance} = ${instanceFetcher};
+                    if (!${parameterResolverFoundVar}) {
+                        ${parameterResolverFoundVar} = true;
+                        parameters.${parameter.parameter.name} = await ${instance}.resolve({
+                            token: ${injectorTokenVar},
+                            route: ${routeConfigVar},
+                            request: request,
+                            name: ${JSON.stringify(parameter.parameter.name)},
+                            value: parameters.${parameter.parameter.name},
+                            query: _query,
+                            parameters: parameters,
+                            type: ${compiler.reserveVariable('parameterType', parameter.parameter)}
+                        });
+                    }`);
+            }
+
+            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) {}`;
+                }
+                setParameters.push(`if (!${parameterResolverFoundVar}) ${injectorGet}`);
+            }
+        }
+    }
+
+
+    let parseBodyLoading = '';
+    if (enableParseBody) {
+        const parseOptionsVar = compiler.reserveVariable('parseOptions', parseOptions);
+        const parseBodyVar = compiler.reserveVariable('parseBody', parseBody);
+        parseBodyLoading = `
+            const bodyFields = (await ${parseBodyVar}(${parseOptionsVar}, request, uploadedFiles));`;
+        requiresAsyncParameters = true;
+    }
+
+    let parametersLoader = '() => {}';
+
+    if (setParameters.length) {
+        parametersLoader = `${requiresAsyncParameters ? 'async' : ''} function parse(_injector){
+                const validationErrors = [];
+                const bodyErrors = [];
+                const parameters = {};
+                ${setParametersFromPath}
+                ${parseBodyLoading}
+                ${setParameters.join('\n')}
+                ${parameterValidator.join('\n')}
+                ${bodyValidationErrorHandling}
+                if (validationErrors.length) throw new ValidationError(validationErrors);
+                return {arguments: [${parameterNames.join(',')}], parameters: parameters};
+            }`;
+    }
+    return parametersLoader;
+}