@deepkit/http 1.0.1-alpha.94 → 1.0.1-alpha.96

package/src/module.config.ts

@@ -1,3 +1,95 @@
+export interface HttpParserOptions {
+    /**
+     * sets encoding for incoming form fields
+     *
+     * @default 'utf-8'
+     */
+    encoding?: BufferEncoding | undefined;
+
+    /**
+     * 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 = {};
 }

package/src/module.ts

@@ -1,6 +1,6 @@
 import { HttpListener, HttpResultFormatter, httpWorkflow } from './http.js';
 import { HttpConfig } from './module.config.js';
-import { AddedListener, AppModule, createModule, stringifyListener } from '@deepkit/app';
+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';
@@ -8,7 +8,6 @@ import { HttpControllers } from './controllers.js';
 import { ConsoleTransport, Logger } from '@deepkit/logger';
 import { HttpRequest, HttpResponse } from './model.js';
 import '@deepkit/type';
-import { ClassType } from '@deepkit/core';
 import { httpClass } from './decorator.js';
 import { EventToken } from '@deepkit/event';
 import { metaAnnotation, ReflectionKind, ReflectionParameter, Type } from '@deepkit/type';
@@ -89,10 +88,10 @@ export class HttpModule extends createModule({
             let i = index;
 
             this.addProvider({
-                provide: uniqueType, useFactory: (request: HttpRequest, injector: InjectorContext, config?: RouteConfig) => {
+                provide: uniqueType, useFactory: (httpConfig: HttpConfig, request: HttpRequest, injector: InjectorContext, config?: RouteConfig) => {
                     if (!build) {
                         const params = listener.reflection.getParameters().slice(1);
-                        build = buildRequestParser(params, config?.getFullPath());
+                        build = buildRequestParser(httpConfig.parser, params, config?.getFullPath());
                     }
 
                     const parser = build(request);
@@ -104,7 +103,10 @@ export class HttpModule extends createModule({
         }
     }
 
-    processController(module: AppModule<any>, controller: ClassType) {
+    processController(module: AppModule<any>, config: ControllerConfig) {
+        const controller = config.controller;
+        if (!controller) return;
+
         const httpConfig = httpClass._fetch(controller);
         if (!httpConfig) return;
 

package/src/request-parser.ts

@@ -5,14 +5,15 @@ import {
     findMember,
     getSerializeFunction,
     getValidatorFunction,
-    metaAnnotation, ReflectionFunction,
+    metaAnnotation,
     ReflectionKind,
     ReflectionParameter,
     resolveReceiveType,
     serializer,
     stringifyType,
     Type,
-    typeToObject, ValidationError
+    typeToObject,
+    ValidationError
 } from '@deepkit/type';
 import { BodyValidationError, createRequestWithCachedBody, getRegExp, HttpRequest, ValidatedBody } from './model.js';
 import { RouteConfig, UploadedFile } from './router.js';
@@ -22,13 +23,15 @@ import qs from 'qs';
 
 // @ts-ignore
 import formidable from 'formidable';
+import { HttpParserOptions } from './module.config.js';
 
 
-function parseBody(req: HttpRequest, foundFiles: { [name: string]: UploadedFile }) {
-    const form = formidable({
+function parseBody(
+    options: HttpParserOptions,
+    req: HttpRequest, foundFiles: { [name: string]: UploadedFile }) {
+    const form = formidable(Object.assign(options, {
         multiples: true,
-        hash: 'sha1',
-    });
+    }));
     return asyncOperation((resolve, reject) => {
         function parseData(err: any, fields: any, files: any) {
             if (err) {
@@ -149,7 +152,7 @@ export function parseRoutePathToRegex(path: string, params: ReflectionParameter[
     return { regex: path, parameterNames };
 }
 
-export function buildRequestParser(parameters: ReflectionParameter[], path?: string): (request: HttpRequest) => any[] {
+export function buildRequestParser(parseOptions: HttpParserOptions, parameters: ReflectionParameter[], path?: string): (request: HttpRequest) => any[] {
     const compiler = new CompilerContext();
     const params = parameters.map(v => new ParameterForRequestParser(v));
 
@@ -164,7 +167,7 @@ export function buildRequestParser(parameters: ReflectionParameter[], path?: str
         }
     }
 
-    const code = getRequestParserCodeForParameters(compiler, params, {});
+    const code = getRequestParserCodeForParameters(compiler, parseOptions, params, {});
     compiler.context.set('ValidationError', ValidationError);
     compiler.context.set('qs', qs);
 
@@ -188,13 +191,14 @@ export function buildRequestParser(parameters: ReflectionParameter[], path?: str
 
 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
+        routeConfig?: RouteConfig,
     }
 ) {
     let enableParseBody = false;
@@ -314,9 +318,10 @@ export function getRequestParserCodeForParameters(
 
     let parseBodyLoading = '';
     if (enableParseBody) {
+        const parseOptionsVar = compiler.reserveVariable('parseOptions', parseOptions);
         const parseBodyVar = compiler.reserveVariable('parseBody', parseBody);
         parseBodyLoading = `
-            const bodyFields = (await ${parseBodyVar}(request, uploadedFiles));`;
+            const bodyFields = (await ${parseBodyVar}(${parseOptionsVar}, request, uploadedFiles));`;
         requiresAsyncParameters = true;
     }
 

package/src/router.ts

@@ -21,6 +21,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';
 
 export type RouteParameterResolverForInjector = ((injector: InjectorContext) => HttpRequestPositionedParameters | Promise<HttpRequestPositionedParameters>);
 
@@ -215,7 +216,10 @@ export interface RouteParameterResolverContext {
     type: ReflectionParameter;
 }
 
-function filterMiddlewaresForRoute(middlewareRawConfigs: MiddlewareRegistryEntry[], routeConfig: RouteConfig, fullPath: string): { config: HttpMiddlewareConfig, module: InjectorModule<any> }[] {
+function filterMiddlewaresForRoute(middlewareRawConfigs: MiddlewareRegistryEntry[], routeConfig: RouteConfig, fullPath: string): {
+    config: HttpMiddlewareConfig,
+    module: InjectorModule<any>
+}[] {
     const middlewares = middlewareRawConfigs.slice(0);
     middlewares.push(...routeConfig.middlewares as any[]);
 
@@ -526,11 +530,11 @@ export class HttpRouter {
     protected buildId: number = 0;
     protected resolveFn?: (name: string, parameters: { [name: string]: any }) => string;
 
-
     constructor(
         controllers: HttpControllers,
         private logger: LoggerInterface,
         tagRegistry: TagRegistry,
+        private config: HttpConfig,
         private middlewareRegistry: MiddlewareRegistry = new MiddlewareRegistry,
         private registry: HttpRouterRegistry = new HttpRouterRegistry,
     ) {
@@ -547,11 +551,12 @@ export class HttpRouter {
         controllers: (ClassType | { module: InjectorModule<any>, controller: ClassType })[],
         tagRegistry: TagRegistry = new TagRegistry(),
         middlewareRegistry: MiddlewareRegistry = new MiddlewareRegistry(),
-        module: InjectorModule<any> = new InjectorModule()
+        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, middlewareRegistry);
+        })), new Logger([], []), tagRegistry, config, middlewareRegistry);
     }
 
     protected getRouteCode(compiler: CompilerContext, routeConfig: RouteConfig): string {
@@ -600,7 +605,7 @@ export class HttpRouter {
             `;
         }
 
-        const parametersLoader = getRequestParserCodeForParameters(compiler, parameters, {
+        const parametersLoader = getRequestParserCodeForParameters(compiler, this.config.parser, parameters, {
             module: routeConfig.module,
             resolverForToken: routeConfig.resolverForToken,
             resolverForParameterName: routeConfig.resolverForParameterName,