@deepkit/http 1.0.1-alpha.16 → 1.0.1-alpha.160

package/src/module.config.ts

@@ -1,6 +1,169 @@
-import { t } from '@deepkit/type';
-import { AppModuleConfig } from '@deepkit/app';
+export interface HttpParserOptions {
+    /**
+     * sets encoding for incoming form fields
+     *
+     * @default 'utf-8'
+     */
+    encoding?: string | undefined;
 
-export const config = new AppModuleConfig({
-    debug: t.boolean.default(false)
-});
+    /**
+     * the directory for placing file uploads in. You can move them later by using fs.rename()
+     *
+     * @default os.tmpdir()
+     */
+    uploadDir?: string | undefined;
+
+    /**
+     * to include the extensions of the original files or not
+     *
+     * @default false
+     */
+    keepExtensions?: boolean | undefined;
+
+    /**
+     * allow upload empty files
+     *
+     * @default true
+     */
+    allowEmptyFiles?: boolean | undefined;
+
+    /**
+     * the minium size of uploaded file
+     *
+     * @default 1
+     */
+    minFileSize?: number | undefined;
+
+    /**
+     * limit the amount of uploaded files, set Infinity for unlimited
+     *
+     * @default Infinity
+     */
+    maxFiles?: number | undefined;
+
+    /**
+     * limit the size of uploaded file
+     *
+     * @default 200 * 1024 * 1024
+     */
+    maxFileSize?: number | undefined;
+
+    /**
+     * limit the size of the batch of uploaded files
+     *
+     * @default options.maxFileSize
+     */
+    maxTotalFileSize?: number | undefined;
+
+    /**
+     * limit the number of fields, set 0 for unlimited
+     *
+     * @default 1000
+     */
+    maxFields?: number | undefined;
+
+    /**
+     * limit the amount of memory all fields together (except files) can allocate in bytes
+     *
+     * @default 20 * 1024 * 1024
+     */
+    maxFieldsSize?: number | undefined;
+
+    /**
+     * include checksums calculated for incoming files, set this to some hash algorithm, see
+     * crypto.createHash for available algorithms
+     *
+     * @default false
+     */
+    hashAlgorithm?: string | false | undefined;
+
+    /**
+     * when you call the .parse method, the files argument (of the callback) will contain arrays of
+     * files for inputs which submit multiple files using the HTML5 multiple attribute. Also, the
+     * fields argument will contain arrays of values for fields that have names ending with '[]'
+     *
+     * @default false
+     */
+    multiples?: boolean | undefined;
+
+    enabledPlugins?: string[] | undefined;
+}
+
+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,11 +1,124 @@
-import { httpWorkflow } from './http';
-import { config } from './module.config';
-import { AppModule } from '@deepkit/app';
+import { HttpListener, HttpResultFormatter, httpWorkflow } from './http.js';
+import { HttpConfig } from './module.config.js';
+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';
+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 { ReflectionKind, ReflectionParameter, Type, typeAnnotation } from '@deepkit/type';
+import { buildRequestParser } from './request-parser.js';
+import { InjectorContext } from '@deepkit/injector';
 
-export const HttpModule = new AppModule({
-    name: 'http',
-    config: config,
+function parameterRequiresRequest(parameter: ReflectionParameter): boolean {
+    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 createModuleClass({
+    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
     ],
-}).forRoot();
+    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 (typeAnnotation.getType(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.`);
+        }
+
+        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('event.parameter:' + parameter.name);
+            const uniqueType: Type = { kind: ReflectionKind.literal, literal: unique };
+            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);
+                        if (config) parserCache.set(config, build);
+                    }
+
+                    const parser = build(request);
+                    const result = parser(injector);
+                    return result.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);
+    }
+}