@deepkit/http 1.0.1-alpha.98 → 1.0.1

package/src/middleware.ts

@@ -35,7 +35,7 @@ export class HttpMiddlewareConfig {
     routeNames: string[] = [];
     excludeRouteNames: string[] = [];
 
-    timeout: number = 4_000;
+    timeout?: number;
 
     modules: InjectorModule<any>[] = [];
 

package/src/model.ts

@@ -12,8 +12,8 @@ import { IncomingMessage, OutgoingHttpHeader, OutgoingHttpHeaders, ServerRespons
 import { UploadedFile } from './router.js';
 import * as querystring from 'querystring';
 import { Writable } from 'stream';
-import { metaAnnotation, ReflectionKind, Type, ValidationErrorItem } from '@deepkit/type';
-import { asyncOperation, isArray } from '@deepkit/core';
+import { ReflectionKind, Type, typeAnnotation, ValidationErrorItem } from '@deepkit/type';
+import { asyncOperation, isArray, TypeAnnotation } from '@deepkit/core';
 
 export class HttpResponse extends ServerResponse {
     status(code: number) {
@@ -103,7 +103,7 @@ export class BodyValidationError {
     }
 
     getErrorMessageForPath(path: string): string {
-        return this.getErrorsForPath(path).map(v => v.message).join(', ');
+        return this.getErrorsForPath(path).map(v => v.toString()).join(', ');
     }
 }
 
@@ -116,12 +116,151 @@ export class ValidatedBody<T> {
     }
 }
 
-export type HttpBody<T> = T & { __meta?: ['httpBody'] };
-export type HttpBodyValidation<T> = ValidatedBody<T> & { __meta?: ['httpBodyValidation'] };
-export type HttpPath<T, Options extends { name?: string } = {}> = T & { __meta?: ['httpPath', Options] };
-export type HttpHeader<T, Options extends { name?: string } = {}> = T & { __meta?: ['httpHeader', Options] };
-export type HttpQuery<T, Options extends { name?: string } = {}> = T & { __meta?: ['httpQuery', Options] };
-export type HttpQueries<T, Options extends { name?: string } = {}> = T & { __meta?: ['httpQueries', Options] };
+/**
+ * Marks a parameter as HTTP body and reads the value from the request body.
+ *
+ * @example
+ * ```typescript
+ * class Controller {
+ *   @http.GET('/api')
+ *   route(body: HttpBody<{username: string}>) {
+ *     //body is {username: string} and required
+ *     //could also reference an interface or type alias via `HttpBody<MyInterface>`
+ *   }
+ * }
+ *
+ * // curl /api -d '{"username":"Peter"}'
+ */
+export type HttpBody<T> = T & TypeAnnotation<'httpBody'>;
+export type HttpBodyValidation<T> = ValidatedBody<T> & TypeAnnotation<'httpBodyValidation'>;
+
+export interface HttpRequestParserOptions {
+    withPath?: boolean;
+    withBody?: boolean;
+    withQuery?: boolean;
+    withHeader?: boolean;
+}
+
+/**
+ * Delays the parsing of the path/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 path, 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);
+ * }
+ * ```
+ *
+ * Note that the parsers is based on all defined parameters (e.g. `userId: HttpQuery<string>` => {userId: string}),
+ * and then starts from there applying header, body, and then query values.
+ * This means you also get access to defined path parameters, like:
+ *
+ * ```typescript
+ * @http.GET('teams/:teamId')
+ * async route(teamId: string) {
+ *    //teamId is string
+ * }
+ *
+ * httpWorkflow.onController.listen((event, parser: HttpRequestParser<{teamId: string}>) => {
+ *  const data = await parser();
+ *  console.log(data.teamId);
+ * });
+ * ```
+ *
+ * HttpRequestParser 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,
+ * but in case of requesting the path parameter in for example listeners, this is required.
+ * The name option can be used to change the parameter name.
+ *
+ * @example
+ * ```typescript
+ * app.listen(httpWorkflow.onController, (event, request: HttpRequest, groupId: HttpPath<number>) => {
+ *   console.log(groupId); //123
+ * });
+ *
+ * class Controller {
+ *   @http.GET('/api/:groupId')
+ *   route(groupId: number) {
+ *     //groupId is number and required
+ *     //same as `groupId: HttpPath<number>`
+ *   }
+ * }
+ * ```
+ */
+export type HttpPath<T, Options extends { name?: string } = {}> = T & TypeAnnotation<'httpPath', Options>;
+
+/**
+ * Marks a parameter as HTTP header and reads the value from the request header.
+ *
+ * @example
+ * ```typescript
+ * class Controller {
+ *    @http.GET('/api')
+ *    route(authorization: HttpHeader<string>) {
+ *         //authorization is string and required
+ *         //use `authorization?: HttpHeader<string>` to make it optional
+ *    }
+ * }
+ *
+ * // curl /api -H 'Authorization: 123'
+ * ```
+ *
+ * To change the header name, use `param: HttpHeader<string, {name: 'X-My-Header'}>`.
+ */
+export type HttpHeader<T, Options extends { name?: string } = {}> = T & TypeAnnotation<'httpHeader', Options>;
+
+/**
+ * Marks a parameter as HTTP query and reads the value from the request query string.
+ *
+ * @example
+ * ```typescript
+ * class Controller {
+ *   @http.GET('/api')
+ *   route(limit: HttpQuery<number>) {
+ *      //limit is number and required
+ *      //use `limit?: HttpQuery<number>` to make it optional
+ *   }
+ * }
+ *
+ * // curl /api?limit=10
+ * ```
+ */
+export type HttpQuery<T, Options extends { name?: string } = {}> = T & TypeAnnotation<'httpQuery', Options>;
+
+/**
+ * Marks a parameter as HTTP query objects and reads multiple values from the request query string into an object.
+ *
+ * @example
+ * ```typescript
+ * interface Query {
+ *    limit?: number;
+ *    offset?: number;
+ *    sort?: 'asc' | 'desc';
+ * }
+ *
+ * class Controller {
+ *  @http.GET('/api')
+ *  route(query: HttpQueries<Query>) {
+ *    //query is an object containing limit, offset, and sort
+ * }
+ *
+ * // curl /api?limit=10&offset=20&sort=asc
+ */
+export type HttpQueries<T, Options extends { name?: string } = {}> = T & TypeAnnotation<'httpQueries', Options>;
 
 /**
  * For all parameters used in the URL path, a regular expression of /[^/]+/ is used. To change that, use getRegExp.
@@ -137,13 +276,13 @@ export type HttpQueries<T, Options extends { name?: string } = {}> = T & { __met
  * }
  * ```
  */
-export type HttpRegExp<T, Pattern extends string | RegExp> = T & { __meta?: ['httpRegExp', Pattern] };
+export type HttpRegExp<T, Pattern extends string | RegExp> = T & TypeAnnotation<'httpRegExp', Pattern>;
 
 export function getRegExp(type: Type): string | RegExp | undefined {
-    const options = metaAnnotation.getForName(type, 'httpRegExp');
-    if (!options || !options[0]) return;
-    if (options[0].kind === ReflectionKind.literal && 'string' === typeof options[0].literal) return options[0].literal;
-    if (options[0].kind === ReflectionKind.literal && options[0].literal instanceof RegExp) return options[0].literal;
+    const options = typeAnnotation.getType(type, 'httpRegExp');
+    if (!options) return;
+    if (options.kind === ReflectionKind.literal && 'string' === typeof options.literal) return options.literal;
+    if (options.kind === ReflectionKind.literal && options.literal instanceof RegExp) return options.literal;
     return;
 }
 
@@ -226,8 +365,12 @@ Content-Type: application/json\r
         return this;
     }
 
-    query(query: any): this {
-        this.queryPath = querystring.stringify(query);
+    query(query: any | string): this {
+        if ('string' === typeof query) {
+            this.queryPath = query;
+        } else {
+            this.queryPath = querystring.stringify(query);
+        }
         return this;
     }
 }
@@ -240,6 +383,8 @@ export class HttpRequest extends IncomingMessage {
 
     public uploadedFiles: { [name: string]: UploadedFile } = {};
 
+    public throwErrorOnNotFound: boolean = false;
+
     /**
      * The router sets the body when it was read.
      */
@@ -299,6 +444,20 @@ export class HttpRequest extends IncomingMessage {
     }
 }
 
+export function incomingMessageToHttpRequest(request: IncomingMessage): HttpRequest {
+    if (request instanceof HttpRequest) return request;
+    Object.setPrototypeOf(request, HttpRequest.prototype);
+    HttpRequest.constructor.call(request);
+    return request as HttpRequest;
+}
+
+export function serverResponseToHttpResponse(response: ServerResponse): HttpResponse {
+    if (response instanceof HttpResponse) return response;
+    Object.setPrototypeOf(response, HttpResponse.prototype);
+    MemoryHttpResponse.constructor.call(response);
+    return response as HttpResponse;
+}
+
 export class MemoryHttpResponse extends HttpResponse {
     public body: Buffer = Buffer.alloc(0);
     public headers: { [name: string]: number | string | string[] | undefined } = Object.create(null);

package/src/module.config.ts

@@ -4,7 +4,7 @@ export interface HttpParserOptions {
      *
      * @default 'utf-8'
      */
-    encoding?: BufferEncoding | undefined;
+    encoding?: string | undefined;
 
     /**
      * the directory for placing file uploads in. You can move them later by using fs.rename()
@@ -90,6 +90,80 @@ export interface HttpParserOptions {
 }
 
 export class HttpConfig {
+
     debug: boolean = false;
+
     parser: HttpParserOptions = {};
+
+    /**
+     * Limits maximum incoming headers count. If set to 0, no limit will be applied.
+     */
+    maxHeadersCount?: number;
+
+    /**
+     * The maximum number of requests socket can handle
+     * before closing keep alive connection.
+     *
+     * A value of `0` will disable the limit.
+     *
+     * When the limit is reached it will set the `Connection` header value to `close`,
+     * but will not actually close the connection, subsequent requests sent
+     * after the limit is reached will get `503 Service Unavailable` as a response.
+     */
+    maxRequestsPerSocket?: number;
+
+    /**
+     * The number of milliseconds of inactivity before a socket is presumed
+     * to have timed out.
+     *
+     * A value of `0` will disable the timeout behavior on incoming connections.
+     *
+     * The socket timeout logic is set up on connection, so changing this
+     * value only affects new connections to the server, not any existing connections.
+     */
+    timeout?: number;
+
+    /**
+     * Limit the amount of time the parser will wait to receive the complete HTTP
+     * headers.
+     *
+     * If the timeout expires, the server responds with status 408 without
+     * forwarding the request to the request listener and then closes the connection.
+     *
+     * It must be set to a non-zero value (e.g. 120 seconds) to protect against
+     * potential Denial-of-Service attacks in case the server is deployed without a
+     * reverse proxy in front.
+     */
+    headersTimeout?: number;
+
+    /**
+     * The number of milliseconds of inactivity a server needs to wait for additional
+     * incoming data, after it has finished writing the last response, before a socket
+     * will be destroyed. If the server receives new data before the keep-alive
+     * timeout has fired, it will reset the regular inactivity timeout, i.e., `server.timeout`.
+     *
+     * A value of `0` will disable the keep-alive timeout behavior on incoming
+     * connections.
+     * A value of `0` makes the http server behave similarly to Node.js versions prior
+     * to 8.0.0, which did not have a keep-alive timeout.
+     *
+     * The socket timeout logic is set up on connection, so changing this value only
+     * affects new connections to the server, not any existing connections.
+     */
+    keepAliveTimeout?: number;
+
+    /**
+     * Sets the timeout value in milliseconds for receiving the entire request from
+     * the client.
+     *
+     * If the timeout expires, the server responds with status 408 without
+     * forwarding the request to the request listener and then closes the connection.
+     *
+     * It must be set to a non-zero value (e.g. 120 seconds) to protect against
+     * potential Denial-of-Service attacks in case the server is deployed without a
+     * reverse proxy in front.
+     *
+     * Default is 5 minutes.
+     */
+    requestTimeout?: number;
 }

package/src/module.ts

@@ -1,6 +1,6 @@
 import { HttpListener, HttpResultFormatter, httpWorkflow } from './http.js';
 import { HttpConfig } from './module.config.js';
-import { AddedListener, AppModule, ControllerConfig, createModule, stringifyListener } from '@deepkit/app';
+import { AddedListener, AppModule, ControllerConfig, createModuleClass, stringifyListener } from '@deepkit/app';
 import { HttpRouter, HttpRouterRegistry, RouteConfig } from './router.js';
 import { HttpKernel } from './kernel.js';
 import { HttpRouterFilterResolver } from './filter.js';
@@ -10,16 +10,21 @@ 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 { ReflectionKind, ReflectionParameter, Type, typeAnnotation } 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'));
+    return Boolean(typeAnnotation.getType(parameter.type, 'httpQueries')
+        || typeAnnotation.getType(parameter.type, 'httpQuery')
+        || typeAnnotation.getType(parameter.type, 'httpBody')
+        || typeAnnotation.getType(parameter.type, 'httpRequestParser')
+        || typeAnnotation.getType(parameter.type, 'httpPath')
+        || typeAnnotation.getType(parameter.type, 'httpHeader'));
 }
 
-export class HttpModule extends createModule({
+
+export class HttpModule extends createModuleClass({
     config: HttpConfig,
     providers: [
         HttpRouter,
@@ -67,7 +72,7 @@ export class HttpModule extends createModule({
         const params = listener.reflection.getParameters().slice(1);
 
         for (const parameter of params) {
-            if (metaAnnotation.getForName(parameter.type, 'httpBody')) needsAsync = true;
+            if (typeAnnotation.getType(parameter.type, 'httpBody')) needsAsync = true;
             if (parameterRequiresRequest(parameter)) requiresHttpRequest = true;
         }
 
@@ -76,27 +81,30 @@ 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.`);
         }
 
+        const parserCache = new Map<RouteConfig, 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;
+            typeAnnotation.registerType(parameter.type, { name: 'inject', options: uniqueType });
             let i = index;
 
             this.addProvider({
                 provide: uniqueType, useFactory: (httpConfig: HttpConfig, request: HttpRequest, injector: InjectorContext, config?: RouteConfig) => {
+                    let build = config && parserCache.get(config);
                     if (!build) {
                         const params = listener.reflection.getParameters().slice(1);
-                        build = buildRequestParser(httpConfig.parser, params, config?.getFullPath());
+                        build = buildRequestParser(httpConfig.parser, params, config);
+                        if (config) parserCache.set(config, build);
                     }
 
                     const parser = build(request);
-                    const params = parser(injector);
-                    return params.arguments[i];
+                    const result = parser(injector);
+                    return result.arguments[i];
                 }, scope: 'http'
             });
             this.addExport(uniqueType);