@deepkit/http 1.0.1-alpha.59 → 1.0.1-alpha.63

package/src/decorator.ts

@@ -11,27 +11,25 @@
 import { ClassType, isClass, urlJoin } from '@deepkit/core';
 import {
     ClassDecoratorResult,
-    ClassSchema,
     createClassDecoratorContext,
     createPropertyDecoratorContext,
-    FieldDecoratorResult,
-    getClassSchema,
+    DecoratorAndFetchSignature,
+    DualDecorator,
+    ExtractApiDataType,
+    ExtractClass,
     isDecoratorContext,
-    isFieldDecorator,
-    JitConverterOptions,
     mergeDecorator,
-    PropertyDecoratorResult,
-    PropertySchema,
+    PropertyDecoratorFn,
+    ReceiveType,
+    resolveReceiveType,
+    SerializationOptions,
     Serializer,
-    t
+    Type,
+    UnionToIntersection
 } from '@deepkit/type';
 import { RouteParameterResolver } from './router';
 import { httpMiddleware, HttpMiddleware, HttpMiddlewareConfig, HttpMiddlewareFn } from './middleware';
 
-export interface ControllerOptions {
-    name: string;
-}
-
 type HttpActionMiddleware = (() => HttpMiddlewareConfig) | ClassType<HttpMiddleware> | HttpMiddlewareFn;
 
 function isMiddlewareClassTypeOrFn(v: HttpActionMiddleware): v is ClassType<HttpMiddleware> | HttpMiddlewareFn {
@@ -99,24 +97,17 @@ export class HttpAction {
     groups: string[] = [];
     serializer?: Serializer;
     middlewares: (() => HttpMiddlewareConfig)[] = [];
-    serializationOptions?: JitConverterOptions;
-
-    parameterRegularExpressions: { [name: string]: any } = {};
+    serializationOptions?: SerializationOptions;
 
     resolverForToken: Map<any, ClassType> = new Map();
     resolverForParameterName: Map<string, ClassType> = new Map();
 
-    /**
-     * This is only filled when the user used @http.body() for example on an method argument.
-     */
-    parameters: { [name: string]: HttpActionParameter } = {};
-
     /**
      * An arbitrary data container the user can use to store app specific settings/values.
      */
     data = new Map<any, any>();
 
-    responses: { statusCode: number, description: string, type?: PropertySchema }[] = [];
+    responses: { statusCode: number, description: string, type?: Type }[] = [];
 }
 
 export class HttpDecorator {
@@ -196,7 +187,8 @@ export const httpClass: ClassDecoratorResult<typeof HttpDecorator> = createClass
 export class HttpActionDecorator {
     t = new HttpAction;
 
-    onDecorator(target: ClassType, property: string) {
+    onDecorator(target: ClassType, property: string | undefined, parameterIndexOrDescriptor?: any) {
+        if (!property) return;
         this.t.methodName = property;
         httpClass.setAction(this.t)(target);
     }
@@ -205,15 +197,11 @@ export class HttpActionDecorator {
         this.t.name = name;
     }
 
-    setParameter(name: string, parameter: HttpActionParameter) {
-        this.t.parameters[name] = parameter;
-    }
-
     description(description: string) {
         this.t.description = description;
     }
 
-    serialization(options: JitConverterOptions) {
+    serialization(options: SerializationOptions) {
         this.t.serializationOptions = options;
     }
 
@@ -298,12 +286,12 @@ export class HttpActionDecorator {
     }
 
     OPTIONS(path: string = '') {
-        this.t.httpMethods.push('HEAD');
+        this.t.httpMethods.push('OPTIONS');
         if (path) this.t.path = path;
     }
 
     TRACE(path: string = '') {
-        this.t.httpMethods.push('HEAD');
+        this.t.httpMethods.push('TRACE');
         if (path) this.t.path = path;
     }
 
@@ -319,31 +307,29 @@ export class HttpActionDecorator {
 
     /**
      * Adds additional information about what HTTP status codes are available in this route.
-     * You can add additionally a description and a class type.
+     * You can add additionally a description and a response body type.
      *
-     * The class type is used for serialization for responses with the given statusCode.
+     * The type is used for serialization for responses with the given statusCode.
      *
-     * Those information are available in Deepkit API console.
-     *
-     * classType can be a schema, class, or deepkit/type t.
+     * This information is available in Deepkit API console.
      *
      * ```typescript
      *
-     * @http.GET().response(200, 'All ok', t.boolean)
+     * @http.GET().response<boolean>(200, 'All ok')
      *
-     * class User {
-     *     @t username: string = '';
+     * interface User {
+     *     username: string;
      * }
-     * @http.GET().response(200, 'User object', User)
-     *
+     * @http.GET().response<User>(200, 'User object')
      *
-     * const error = t.schema({error: t.string});
-     * @http.GET().response(500, 'Error', error)
+     * interface HttpErrorMessage {
+     *     error: string;
+     * }
+     * @http.GET().response<HttpErrorMessage>(500, 'Error')
      * ```
      */
-    response(statusCode: number, description: string = '', classType?: FieldDecoratorResult<any> | ClassType | ClassSchema,) {
-        const type = classType ? (isFieldDecorator(classType) ? classType.buildPropertySchema() : t.type(getClassSchema(classType)).buildPropertySchema()) : undefined;
-        this.t.responses.push({ statusCode, description, type });
+    response<T>(statusCode: number, description: string = '', type?: ReceiveType<T>) {
+        this.t.responses.push({ statusCode, description, type: type ? resolveReceiveType(type) : undefined });
     }
 
     /**
@@ -395,95 +381,20 @@ export class HttpActionDecorator {
     resolveParameterByName(name: string, resolver: ClassType<RouteParameterResolver>) {
         this.t.resolverForParameterName.set(name, resolver);
     }
-
-    regexp(parameterName: string, regex: any) {
-        this.t.parameterRegularExpressions[parameterName] = regex;
-    }
 }
 
-class HttpActionParameterDecorator {
-    t = new HttpActionParameter();
-
-    onDecorator(target: ClassType, propertyName?: string, parameterIndex?: number) {
-        if (!propertyName) throw new Error('@http action parameter decorator can only be used on method arguments.');
-        if (parameterIndex === undefined) throw new Error('@http action parameter decorator can only be used on method arguments.');
-        const schema = getClassSchema(target);
-        const property = schema.getMethodProperties(propertyName)[parameterIndex];
-        this.t.name = property.name;
-        if (this.t.typePath === undefined) {
-            this.t.typePath = property.name;
-        }
-        httpAction.setParameter(property.name, this.t)(target.prototype, propertyName);
-    }
-
-    /**
-     * Marks the argument as body parameter. Data from the client sent in the body
-     * will be tried to parsed (JSON/form data) and deserialized to the defined type.
-     * Make sure the class type as a schema assigned.
-     *
-     * @example
-     * ```typescript
-     * class MyActionBody {
-     *     @t name!: string;
-     * }
-     *
-     * class Controller {
-     *     @http.GET()
-     *     myAction(@http.body() body: MyActionBody) {
-     *         console.log('body', body.name);
-     *     }
-     * }
-     * ```
-     */
-    body() {
-        this.t.type = 'body';
-        this.t.typePath = ''; //root
-    }
-
-    query(path?: string) {
-        this.t.typePath = path; //undefined === propertyName
-        this.t.type = 'query';
-    }
-
-    get optional() {
-        this.t.optional = true;
-        return;
-    }
-
-    /**
-     * Marks the argument as query parameter. Data from the query string is parsed
-     * and deserialized to the defined type.
-     * Define a `path` if you want to parse a subset of the query string only.
-     *
-     * Note: Make sure the defined parameter type has optional properties,
-     * otherwise it's always required to pass a query string.
-     *
-     * @example
-     * ```typescript
-     * class MyActionQueries {
-     *     @t.optional name?: string;
-     * }
-     *
-     * class Controller {
-     *     @http.GET('my-action')
-     *     myAction(@http.queries() query: MyActionQueries) {
-     *         console.log('query', query.name);
-     *     }
-     * }
-     *
-     * // Open via, e.g.
-     * // -> /my-action?name=Peter
-     * ```
-     *
-     */
-    queries(path: string = '') {
-        this.t.typePath = path; //'' === root
-        this.t.type = 'queries';
-    }
-}
+//this workaround is necessary since generic functions (necessary for response<T>) are lost during a mapped type and changed ReturnType
+type HttpActionFluidDecorator<T, D extends Function> = {
+    [name in keyof T]: name extends 'response' ? <T2>(statusCode: number, description?: string, type?: ReceiveType<T2>) => D & HttpActionFluidDecorator<T, D>
+        : T[name] extends (...args: infer K) => any ? (...args: K) => D & HttpActionFluidDecorator<T, D>
+        : D & HttpActionFluidDecorator<T, D> & { _data: ExtractApiDataType<T> };
+};
+type HttpActionPropertyDecoratorResult = HttpActionFluidDecorator<ExtractClass<typeof HttpActionDecorator>, PropertyDecoratorFn> & DecoratorAndFetchSignature<typeof HttpActionDecorator, PropertyDecoratorFn>;
 
-export const httpAction: PropertyDecoratorResult<typeof HttpActionDecorator> = createPropertyDecoratorContext(HttpActionDecorator);
+export const httpAction: HttpActionPropertyDecoratorResult = createPropertyDecoratorContext(HttpActionDecorator);
 
-export const httpActionParameter: PropertyDecoratorResult<typeof HttpActionParameterDecorator> = createPropertyDecoratorContext(HttpActionParameterDecorator);
+//this workaround is necessary since generic functions are lost during a mapped type and changed ReturnType
+type HttpMerge<U> = { [K in keyof U]: K extends 'response' ? <T2>(statusCode: number, description?: string, type?: ReceiveType<T2>) => PropertyDecoratorFn & U : U[K] extends ((...a: infer A) => infer R) ? R extends DualDecorator ? (...a: A) => PropertyDecoratorFn & R & U : (...a: A) => R : never };
+type MergedHttp<T extends any[]> = HttpMerge<Omit<UnionToIntersection<T[number]>, '_fetch' | 't'>>
 
-export const http = mergeDecorator(httpClass, httpAction, httpActionParameter);
+export const http: MergedHttp<[typeof httpClass, typeof httpAction]> = mergeDecorator(httpClass, httpAction) as any as MergedHttp<[typeof httpClass, typeof httpAction]>;

package/src/filter.ts

@@ -1,7 +1,6 @@
 import { ClassType } from '@deepkit/core';
 import { AppModule } from '@deepkit/app';
 import { RouteConfig, Router } from './router';
-import { injectable } from '@deepkit/injector';
 
 export interface HttpRouteFilterRoute {
     path?: string;
@@ -57,7 +56,6 @@ function match(routeConfig: RouteConfig, route: HttpRouteFilterRoute): boolean {
     return false;
 }
 
-@injectable
 export class HttpRouterFilterResolver {
     constructor(protected router: Router) {
     }

package/src/http.ts

@@ -8,17 +8,17 @@
  * You should have received a copy of the MIT License along with this program.
  */
 
-import { asyncOperation, ClassType, CustomError, getClassName } from '@deepkit/core';
-import { getClassTypeFromInstance, getPropertyClassToXFunction, isClassInstance, isRegisteredEntity, jsonSerializer, ValidationFailed } from '@deepkit/type';
+import { asyncOperation, ClassType, CustomError, getClassName, getClassTypeFromInstance, isClassInstance } from '@deepkit/core';
 import { OutgoingHttpHeaders, ServerResponse } from 'http';
 import { eventDispatcher } from '@deepkit/event';
 import { HttpRequest, HttpResponse } from './model';
-import { inject, injectable, InjectorContext } from '@deepkit/injector';
-import { Logger } from '@deepkit/logger';
+import { InjectorContext } from '@deepkit/injector';
+import { LoggerInterface } from '@deepkit/logger';
 import { RouteConfig, RouteParameterResolverForInjector, Router } from './router';
 import { createWorkflow, WorkflowEvent } from '@deepkit/workflow';
 import type { ElementStruct, render } from '@deepkit/template';
 import { FrameCategory, Stopwatch } from '@deepkit/stopwatch';
+import { getSerializeFunction, hasTypeInformation, ReflectionKind, resolveReceiveType, SerializationError, serialize, serializer, ValidationError } from '@deepkit/type';
 
 export function isElementStruct(v: any): v is ElementStruct {
     return 'object' === typeof v && v.hasOwnProperty('render') && v.hasOwnProperty('attributes') && !v.slice;
@@ -350,7 +350,6 @@ export interface HttpResultFormatterContext {
     route?: RouteConfig;
 }
 
-@injectable
 export class HttpResultFormatter {
     protected jsonContentType: string = 'application/json; charset=utf-8';
     protected htmlContentType: string = 'text/html; charset=utf-8';
@@ -406,14 +405,9 @@ export class HttpResultFormatter {
     handleTypeEntity<T>(classType: ClassType<T>, instance: T, context: HttpResultFormatterContext, route?: RouteConfig): void {
         this.setContentTypeIfNotSetAlready(context.response, this.jsonContentType);
 
-        context.response.end(JSON.stringify(
-                (route && route?.serializer ? route.serializer : jsonSerializer)
-                    .for(classType).serialize(
-                    instance,
-                    route ? route.serializationOptions : undefined
-                )
-            )
-        );
+        const serializerToUse = route && route?.serializer ? route.serializer : serializer;
+
+        context.response.end(JSON.stringify(serialize(instance, route ? route.serializationOptions : undefined, serializerToUse, undefined, resolveReceiveType(classType))));
     }
 
     handleBinary(result: Uint8Array, context: HttpResultFormatterContext): void {
@@ -441,7 +435,7 @@ export class HttpResultFormatter {
         } else {
             if (isClassInstance(result)) {
                 const classType = getClassTypeFromInstance(result);
-                if (isRegisteredEntity(classType)) {
+                if (hasTypeInformation(classType)) {
                     this.handleTypeEntity(classType, result, context);
                     return;
                 }
@@ -452,13 +446,12 @@ export class HttpResultFormatter {
     }
 }
 
-@injectable
 export class HttpListener {
     constructor(
         protected router: Router,
-        protected logger: Logger,
+        protected logger: LoggerInterface,
         protected resultFormatter: HttpResultFormatter,
-        @inject().optional protected stopwatch?: Stopwatch,
+        protected stopwatch?: Stopwatch,
     ) {
     }
 
@@ -573,7 +566,7 @@ export class HttpListener {
         try {
             event.parameters = await event.parameterResolver(event.injectorContext);
             event.next('controller', new HttpControllerEvent(event.injectorContext, event.request, event.response, event.parameters, event.route));
-        } catch (error) {
+        } catch (error: any) {
             event.next('parametersFailed', new HttpControllerErrorEvent(event.injectorContext, event.request, event.response, event.route, error));
         }
     }
@@ -606,7 +599,7 @@ export class HttpListener {
             const responseEvent = new HttpResponseEvent(event.injectorContext, event.request, event.response, result, event.route);
             responseEvent.controllerActionTime = Date.now() - start;
             event.next('response', responseEvent);
-        } catch (error) {
+        } catch (error: any) {
             if (frame) frame.end();
             if (error instanceof HttpAccessDeniedError) {
                 event.next('accessDenied', new HttpAccessDeniedEvent(event.injectorContext, event.request, event.response, event.route));
@@ -625,7 +618,16 @@ export class HttpListener {
         if (event.response.finished) return;
         if (event.sent) return;
 
-        if (event.error instanceof ValidationFailed) {
+        if (event.error instanceof SerializationError) {
+            event.send(new JSONResponse({
+                message: event.error.message,
+                errors: [{
+                    path: event.error.path,
+                    code: 'serialization',
+                    message: event.error.originalMessage,
+                }]
+            }, 400).disableAutoSerializing());
+        } else if (event.error instanceof ValidationError) {
             event.send(new JSONResponse({
                 message: event.error.message,
                 errors: event.error.errors
@@ -642,7 +644,7 @@ export class HttpListener {
         if (event.response.finished) return;
         if (event.sent) return;
 
-        if (event.error instanceof ValidationFailed) {
+        if (event.error instanceof ValidationError) {
             event.send(new JSONResponse({
                 message: event.error.message,
                 errors: event.error.errors
@@ -672,28 +674,25 @@ export class HttpListener {
         if (event.result instanceof HtmlResponse || event.result instanceof ServerResponse || event.result instanceof Redirect) {
             // don't do anything
         } else if (event.result instanceof JSONResponse) {
-            const schema = (event.result._statusCode && event.route.getSchemaForResponse(event.result._statusCode)) || event.route.returnSchema;
+            const schema = (event.result._statusCode && event.route.getSchemaForResponse(event.result._statusCode)) || event.route.returnType;
 
             if (!schema || !event.result.autoSerializing) return;
 
-            event.result.json = getPropertyClassToXFunction(
-                schema,
-                event.route && event.route.serializer ? event.route.serializer : jsonSerializer
-            )(event.result.json, event.route.serializationOptions);
-        } else if (event.route.returnSchema && (!event.route.returnSchema.isPromise || event.route.returnSchema.getSubType())) {
-            event.result = getPropertyClassToXFunction(
-                event.route.returnSchema,
-                event.route && event.route.serializer ? event.route.serializer : jsonSerializer
-            )(event.result, event.route.serializationOptions);
+            const serializerToUse = event.route && event.route.serializer ? event.route.serializer : serializer;
+            const serialize = getSerializeFunction(schema, serializerToUse.serializeRegistry);
+            event.result.json = serialize(event.result.json, event.route.serializationOptions);
+        } else if (event.route.returnType && event.route.returnType.kind !== ReflectionKind.any) {
+            const serializerToUse = event.route && event.route.serializer ? event.route.serializer : serializer;
+            const serialize = getSerializeFunction(event.route.returnType, serializerToUse.serializeRegistry);
+            event.result = serialize(event.result, event.route.serializationOptions);
         } else {
             const schema = event.route.getSchemaForResponse(200);
             if (!schema) return;
-            event.result = getPropertyClassToXFunction(
-                schema,
-                event.route && event.route.serializer ? event.route.serializer : jsonSerializer
-            )(event.result, event.route.serializationOptions);
-        }
 
+            const serializerToUse = event.route && event.route.serializer ? event.route.serializer : serializer;
+            const serialize = getSerializeFunction(schema, serializerToUse.serializeRegistry);
+            event.result = serialize(event.result, event.route.serializationOptions);
+        }
     }
 
     @eventDispatcher.listen(httpWorkflow.onResponse, 100)

package/src/kernel.ts

@@ -1,20 +1,19 @@
-import { inject, injectable, InjectorContext } from '@deepkit/injector';
+import { InjectorContext } from '@deepkit/injector';
 import { Router } from './router';
 import { EventDispatcher } from '@deepkit/event';
-import { Logger } from '@deepkit/logger';
+import { LoggerInterface } from '@deepkit/logger';
 import { HttpRequest, HttpResponse, MemoryHttpResponse, RequestBuilder } from './model';
 import { HttpRequestEvent, httpWorkflow } from './http';
 import { FrameCategory, Stopwatch } from '@deepkit/stopwatch';
 import { unlink } from 'fs';
 
-@injectable
 export class HttpKernel {
     constructor(
         protected router: Router,
         protected eventDispatcher: EventDispatcher,
         protected injectorContext: InjectorContext,
-        protected logger: Logger,
-        @inject().optional protected stopwatch?: Stopwatch,
+        protected logger: LoggerInterface,
+        protected stopwatch?: Stopwatch,
     ) {
 
     }

package/src/logger.ts

@@ -1,11 +1,9 @@
-import { injectable } from '@deepkit/injector';
-import { Logger } from '@deepkit/logger';
+import { LoggerInterface } from '@deepkit/logger';
 import { eventDispatcher } from '@deepkit/event';
 import { httpWorkflow } from './http';
 
-@injectable
 export class HttpLogger {
-    constructor(private logger: Logger) {
+    constructor(private logger: LoggerInterface) {
     }
 
     @eventDispatcher.listen(httpWorkflow.onResponse, 101) //101 is right after 100 default listener

package/src/middleware.ts

@@ -2,6 +2,7 @@ import { ClassType, isClass } from '@deepkit/core';
 import { AppModule } from '@deepkit/app';
 import { createFreeDecoratorContext } from '@deepkit/type';
 import { HttpRequest, HttpResponse } from './model';
+import { InjectorModule } from '@deepkit/injector';
 
 export type HttpMiddlewareFn = (req: HttpRequest, res: HttpResponse, next: (err?: any) => void) => void | Promise<void>;
 
@@ -36,7 +37,7 @@ export class HttpMiddlewareConfig {
 
     timeout: number = 4_000;
 
-    modules: AppModule<any>[] = [];
+    modules: InjectorModule<any>[] = [];
 
     selfModule: boolean = false;
 

package/src/model.ts

@@ -12,6 +12,7 @@ import { IncomingMessage, ServerResponse } from 'http';
 import { UploadedFile } from './router';
 import * as querystring from 'querystring';
 import { Writable } from 'stream';
+import { metaAnnotation, ReflectionKind, Type, ValidationErrorItem } from '@deepkit/type';
 
 export class HttpResponse extends ServerResponse {
     status(code: number) {
@@ -23,6 +24,68 @@ export class HttpResponse extends ServerResponse {
 export type HttpRequestQuery = { [name: string]: string };
 export type HttpRequestResolvedParameters = { [name: string]: any };
 
+export class BodyValidationError {
+    constructor(
+        public readonly errors: ValidationErrorItem[] = []
+    ) {
+    }
+
+    hasErrors(prefix?: string): boolean {
+        return this.getErrors(prefix).length > 0;
+    }
+
+    getErrors(prefix?: string): ValidationErrorItem[] {
+        if (prefix) return this.errors.filter(v => v.path.startsWith(prefix));
+
+        return this.errors;
+    }
+
+    getErrorsForPath(path: string): ValidationErrorItem[] {
+        return this.errors.filter(v => v.path === path);
+    }
+
+    getErrorMessageForPath(path: string): string {
+        return this.getErrorsForPath(path).map(v => v.message).join(', ');
+    }
+}
+
+export class ValidatedBody<T> {
+    constructor(public error: BodyValidationError, public value?: T) {
+    }
+
+    valid(): this is { value: T } {
+        return this.value !== undefined;
+    }
+}
+
+export type HttpBody<T> = T & { __meta?: ['httpBody'] };
+export type HttpBodyValidation<T> = ValidatedBody<T> & { __meta?: ['httpBodyValidation'] };
+export type HttpQuery<T, Options extends { name?: string } = {}> = T & { __meta?: ['httpQuery', Options] };
+export type HttpQueries<T, Options extends { name?: string } = {}> = T & { __meta?: ['httpQueries', Options] };
+
+/**
+ * For all parameters used in the URL path, a regular expression of /[^/]+/ is used. To change that, use getRegExp.
+ *
+ * @example
+ * ```typescript
+ *
+ * class Controller {
+ *     @http.GET('/user/:username')
+ *     route(username: HttpRegExp<string, '.*'>) {
+ *         //username is string
+ *     }
+ * }
+ * ```
+ */
+export type HttpRegExp<T, Pattern extends string> = T & { __meta?: ['httpRegExp', Pattern] };
+
+export function getRegExp(type: Type): string | undefined {
+    const options = metaAnnotation.getForName(type, 'httpRegExp');
+    if (!options || !options[0]) return;
+    if (options[0].kind !== ReflectionKind.literal || 'string' !== typeof options[0].literal) return;
+    return options[0].literal;
+}
+
 export class RequestBuilder {
     protected contentBuffer: Buffer = Buffer.alloc(0);
     protected _headers: { [name: string]: string } = {};
@@ -48,8 +111,9 @@ export class RequestBuilder {
         const bodyContent = this.contentBuffer;
 
         const writable = new Writable({
-            write(chunk, encoding, callback) {-
-                callback();
+            write(chunk, encoding, callback) {
+                -
+                    callback();
             },
             writev(chunks, callback) {
                 callback();
@@ -69,7 +133,7 @@ export class RequestBuilder {
                     this.push(bodyContent);
                     process.nextTick(() => {
                         this.emit('end');
-                    })
+                    });
                     this.done = true;
                 }
             }
@@ -136,6 +200,14 @@ export class HttpRequest extends IncomingMessage {
         return new RequestBuilder(path, 'OPTIONS');
     }
 
+    static TRACE(path: string): RequestBuilder {
+        return new RequestBuilder(path, 'TRACE');
+    }
+
+    static HEAD(path: string): RequestBuilder {
+        return new RequestBuilder(path, 'HEAD');
+    }
+
     static PATCH(path: string): RequestBuilder {
         return new RequestBuilder(path, 'PATCH');
     }
@@ -157,7 +229,7 @@ export class HttpRequest extends IncomingMessage {
     }
 
     getRemoteAddress(): string {
-        return this.connection.remoteAddress || '';
+        return this.socket.remoteAddress || '';
     }
 }
 
@@ -168,7 +240,7 @@ export class MemoryHttpResponse extends HttpResponse {
         const json = this.bodyString;
         try {
             return JSON.parse(json);
-        }  catch (error) {
+        } catch (error: any) {
             throw new Error(`Could not parse JSON: ${error.message}, body: ${json}`);
         }
     }
@@ -181,7 +253,7 @@ export class MemoryHttpResponse extends HttpResponse {
         chunk: any,
         encoding: any,
         callback?: any
-    ): boolean {
+    ): any {
         if (typeof encoding === 'function') {
             callback = encoding;
             encoding = null;
@@ -198,7 +270,7 @@ export class MemoryHttpResponse extends HttpResponse {
         return true;
     }
 
-    end(chunk: any, encoding?: any, callback?: any): void {
+    end(chunk: any, encoding?: any, callback?: any): any {
         if (typeof chunk === 'function') {
             callback = chunk;
             chunk = null;
@@ -214,7 +286,7 @@ export class MemoryHttpResponse extends HttpResponse {
             }
             this.body = Buffer.concat([this.body, chunk]);
         }
-        super.end(chunk, encoding, callback);
+        return super.end(chunk, encoding, callback);
         // if (callback) callback();
     }
 }

package/src/module.config.ts

@@ -1,6 +1,3 @@
-import { t } from '@deepkit/type';
-import { AppModuleConfig } from '@deepkit/app';
-
-export const config = new AppModuleConfig({
-    debug: t.boolean.default(false),
-});
+export class HttpConfig {
+    debug: boolean = false;
+}

package/src/module.ts

@@ -1,5 +1,5 @@
 import { HttpListener, HttpResultFormatter, httpWorkflow } from './http';
-import { config } from './module.config';
+import { HttpConfig } from './module.config';
 import { AppModule, createModule } from '@deepkit/app';
 import { Router } from './router';
 import { HttpKernel } from './kernel';
@@ -12,7 +12,7 @@ import { ClassType } from '@deepkit/core';
 import { httpClass } from './decorator';
 
 export class HttpModule extends createModule({
-    config: config,
+    config: HttpConfig,
     providers: [
         Router,
         HttpKernel,