@deepkit/http 1.0.1-alpha.123 → 1.0.1-alpha.128

package/src/model.ts

@@ -12,7 +12,7 @@ import { IncomingMessage, OutgoingHttpHeader, OutgoingHttpHeaders, ServerRespons
 import { UploadedFile } from './router.js';
 import * as querystring from 'querystring';
 import { Writable } from 'stream';
-import { metaAnnotation, ReflectionKind, Type, ValidationErrorItem, TypeAnnotation } from '@deepkit/type';
+import { metaAnnotation, ReflectionKind, Type, TypeAnnotation, ValidationErrorItem } from '@deepkit/type';
 import { asyncOperation, isArray } from '@deepkit/core';
 
 export class HttpResponse extends ServerResponse {
@@ -134,6 +134,35 @@ export class ValidatedBody<T> {
 export type HttpBody<T> = T & TypeAnnotation<'httpBody'>;
 export type HttpBodyValidation<T> = ValidatedBody<T> & TypeAnnotation<'httpBodyValidation'>;
 
+export interface HttpRequestParserOptions {
+    withBody?: boolean;
+    withQuery?: boolean;
+    withHeader?: boolean;
+}
+
+/**
+ * Delays the parsing of the body/query/header to the very last moment, when the parameter is actually used.
+ *
+ * If no options are provided, the parser will receive data from header, body, and query, in this order.
+ * This basically allows to fetch data from all possible HTTP sources in one go.
+ *
+ * You can disable various sources by providing the options, e.g. `{withBody: false}` to disable body parsing.
+ * Or `{withQuery: false}` to disable query parsing. Or `{withHeader: false}` to disable header parsing.
+ * To only parse the body, use `{withQuery: false, withHeader: false}`.
+ *
+ * @example
+ * ```typescript
+ * async route(parser: HttpRequestParser<{authorization: string}>) {
+ *    const data = await parser();
+ *    console.log(data.authorization);
+ * }
+ * ```
+ *
+ * This is necessary in event listeners, since they are instantiated synchronously,
+ * but body is parsed asynchronously. So use in event listeners HttpRequestParser instead of HttpBody.
+ */
+export type HttpRequestParser<T> = ((options?: HttpRequestParserOptions) => Promise<T>) & TypeAnnotation<'httpRequestParser', T>;
+
 /**
  * Marks a parameter as HTTP path and reads the value from the request path.
  * This is normally not requires since the parameter name automatically maps to the path parameter,

package/src/module.ts

@@ -15,8 +15,12 @@ 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'));
+    return Boolean(metaAnnotation.getForName(parameter.type, 'httpQueries')
+        || metaAnnotation.getForName(parameter.type, 'httpQuery')
+        || metaAnnotation.getForName(parameter.type, 'httpBody')
+        || metaAnnotation.getForName(parameter.type, 'httpRequestParser')
+        || metaAnnotation.getForName(parameter.type, 'httpPath')
+        || metaAnnotation.getForName(parameter.type, 'httpHeader'));
 }
 
 export class HttpModule extends createModule({
@@ -76,15 +80,15 @@ export class HttpModule extends createModule({
             throw new Error(`Listener ${stringifyListener(listener)} requires async HttpBody. This is not yet supported. You have to parse the request manually by injecting HttpRequest.`);
         }
 
+        let build: Function;
         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 unique = Symbol('event.parameter:' + parameter.name);
             const uniqueType: Type = { kind: ReflectionKind.literal, literal: unique };
             metaAnnotation.registerType(parameter.type, { name: 'inject', options: [uniqueType] });
-            let build: Function;
             let i = index;
 
             this.addProvider({

package/src/request-parser.ts

@@ -89,11 +89,20 @@ export class ParameterForRequestParser {
         return metaAnnotation.getForName(this.parameter.type, 'httpBody') !== undefined;
     }
 
+    get requestParser() {
+        return metaAnnotation.getForName(this.parameter.type, 'httpRequestParser') !== undefined;
+    }
+
     get bodyValidation() {
         return metaAnnotation.getForName(this.parameter.type, 'httpBodyValidation') !== undefined;
     }
 
     getType(): Type {
+        const parser = metaAnnotation.getForName(this.parameter.type, 'httpRequestParser');
+        if (parser && parser[0]) {
+            return parser[0];
+        }
+
         if (this.bodyValidation) {
             assertType(this.parameter.type, ReflectionKind.class);
             const valueType = findMember('value', this.parameter.type.types);
@@ -180,7 +189,7 @@ export function buildRequestParser(parseOptions: HttpParserOptions, parameters:
     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 + '$'));
@@ -219,14 +228,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);
@@ -235,6 +241,32 @@ 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);
+                setParameters.push(`parameters.${parameter.parameter.name} = async (options = {}) => {
+                    let res = {};
+                    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);
@@ -343,7 +375,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;
     }
 
@@ -354,6 +386,7 @@ export function getRequestParserCodeForParameters(
                 const validationErrors = [];
                 const bodyErrors = [];
                 const parameters = {};
+                let bodyFields;
                 ${setParametersFromPath}
                 ${parseBodyLoading}
                 ${setParameters.join('\n')}