@deepkit/http 1.0.1-alpha.71 → 1.0.1-alpha.72

package/src/http.ts

@@ -14,11 +14,12 @@ import { eventDispatcher } from '@deepkit/event';
 import { HttpRequest, HttpResponse } from './model';
 import { InjectorContext } from '@deepkit/injector';
 import { LoggerInterface } from '@deepkit/logger';
-import { RouteConfig, RouteParameterResolverForInjector, Router } from './router';
+import { HttpRouter, RouteConfig, RouteParameterResolverForInjector } 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';
+import stream from 'stream';
 
 export function isElementStruct(v: any): v is ElementStruct {
     return 'object' === typeof v && v.hasOwnProperty('render') && v.hasOwnProperty('attributes') && !v.slice;
@@ -73,24 +74,51 @@ export function createHttpError<T extends number>(code: T, defaultMessage: strin
     } as any;
 }
 
-export class HttpNotFoundError extends createHttpError(404, 'Not found') {
+export class HttpBadRequestError extends createHttpError(400, 'Bad request') {
 }
 
-export class HttpBadRequestError extends createHttpError(400, 'Bad request') {
+export class HttpUnauthorizedError extends createHttpError(401, 'Unauthorized') {
 }
 
 export class HttpAccessDeniedError extends createHttpError(403, 'Access denied') {
 }
 
+export class HttpNotFoundError extends createHttpError(404, 'Not found') {
+}
+
+export class HttpMethodNotAllowedError extends createHttpError(405, 'Method not allowed') {
+}
+
+export class HttpNotAcceptableError extends createHttpError(406, 'Not acceptable') {
+}
+
+export class HttpTimeoutError extends createHttpError(408, 'Request timeout') {
+}
+
+export class HttpConflictError extends createHttpError(409, 'Conflict') {
+}
+
+export class HttpGoneError extends createHttpError(410, 'Gone') {
+}
+
+export class HttpTooManyRequestsError extends createHttpError(429, 'Too many requests') {
+}
+
+export class HttpInternalServerError extends createHttpError(500, 'Internal server error') {
+}
+
+export class HttpNotImplementedError extends createHttpError(501, 'Not implemented') {
+}
+
 export class HttpWorkflowEvent {
-    stopped = false;
+    propagationStopped = false;
 
     stopPropagation() {
-        this.stopped = true;
+        this.propagationStopped = true;
     }
 
-    isStopped() {
-        return this.stopped;
+    isPropagationStopped() {
+        return this.propagationStopped;
     }
 
     public nextState?: any;
@@ -309,6 +337,10 @@ export class BaseResponse {
         return this;
     }
 
+    /**
+     * Per default a JSONResponse is serialized using the return type specified at the route.
+     * This disables that behaviour so that JSON.stringify is run on the result directly.
+     */
     disableAutoSerializing() {
         this.autoSerializing = false;
         return this;
@@ -330,6 +362,13 @@ export class BaseResponse {
     }
 }
 
+export class Response extends BaseResponse {
+    constructor(public content: string | Uint8Array, contentType: string, statusCode?: number) {
+        super(statusCode);
+        this.contentType(contentType);
+    }
+}
+
 export class HtmlResponse extends BaseResponse {
     constructor(public html: string, statusCode?: number) {
         super(statusCode);
@@ -342,7 +381,7 @@ export class JSONResponse extends BaseResponse {
     }
 }
 
-export type SupportedHttpResult = undefined | null | number | string | JSONResponse | HtmlResponse | HttpResponse | ServerResponse | Redirect | Uint8Array | Error;
+export type SupportedHttpResult = undefined | null | number | string | Response | JSONResponse | HtmlResponse | HttpResponse | ServerResponse | stream.Readable | Redirect | Uint8Array | Error;
 
 export interface HttpResultFormatterContext {
     request: HttpRequest;
@@ -354,7 +393,7 @@ export class HttpResultFormatter {
     protected jsonContentType: string = 'application/json; charset=utf-8';
     protected htmlContentType: string = 'text/html; charset=utf-8';
 
-    constructor(protected router: Router) {
+    constructor(protected router: HttpRouter) {
     }
 
     protected setContentTypeIfNotSetAlready(response: HttpResponse, contentType: string): void {
@@ -396,6 +435,12 @@ export class HttpResultFormatter {
         context.response.end(result.html);
     }
 
+    handleGenericResponse(result: Response, context: HttpResultFormatterContext): void {
+        context.response.writeHead(result._statusCode || 200, result._headers);
+        console.log('generic response', result.content);
+        context.response.end(result.content);
+    }
+
     handleJSONResponse(result: JSONResponse, context: HttpResultFormatterContext): void {
         this.setContentTypeIfNotSetAlready(context.response, this.jsonContentType);
         context.response.writeHead(result._statusCode || 200, result._headers);
@@ -410,6 +455,10 @@ export class HttpResultFormatter {
         context.response.end(JSON.stringify(serialize(instance, route ? route.serializationOptions : undefined, serializerToUse, undefined, resolveReceiveType(classType))));
     }
 
+    handleStream(stream: stream.Readable, context: HttpResultFormatterContext): void {
+        stream.pipe(context.response);
+    }
+
     handleBinary(result: Uint8Array, context: HttpResultFormatterContext): void {
         context.response.end(result);
     }
@@ -428,10 +477,14 @@ export class HttpResultFormatter {
             this.handleResponse(context);
         } else if (result instanceof HtmlResponse) {
             this.handleHtmlResponse(result, context);
+        } else if (result instanceof stream.Readable) {
+            this.handleStream(result, context);
         } else if (result instanceof Uint8Array) {
             this.handleBinary(result, context);
         } else if (result instanceof JSONResponse) {
             this.handleJSONResponse(result, context);
+        } else if (result instanceof Response) {
+            this.handleGenericResponse(result, context);
         } else {
             if (isClassInstance(result)) {
                 const classType = getClassTypeFromInstance(result);
@@ -448,7 +501,7 @@ export class HttpResultFormatter {
 
 export class HttpListener {
     constructor(
-        protected router: Router,
+        protected router: HttpRouter,
         protected logger: LoggerInterface,
         protected resultFormatter: HttpResultFormatter,
         protected stopwatch?: Stopwatch,
@@ -584,18 +637,34 @@ export class HttpListener {
         if (event.sent) return;
         if (event.hasNext()) return;
 
-        const controllerInstance = event.injectorContext.get(event.route.action.controller, event.route.action.module);
 
         const start = Date.now();
-        const frame = this.stopwatch ? this.stopwatch.start(getClassName(event.route.action.controller) + '.' + event.route.action.methodName, FrameCategory.httpController) : undefined;
+        const stopWatchLabel = event.route.action.type === 'controller'
+            ? getClassName(event.route.action.controller) + '.' + event.route.action.methodName
+            : event.route.action.fn.name;
+
+        const frame = this.stopwatch ? this.stopwatch.start(stopWatchLabel, FrameCategory.httpController) : undefined;
         try {
-            const method = controllerInstance[event.route.action.methodName];
-            let result = await method.apply(controllerInstance, event.parameters);
+            let result: any;
+            if (event.route.action.type === 'controller') {
+                const controllerInstance = event.injectorContext.get(event.route.action.controller, event.route.action.module);
+                const method = controllerInstance[event.route.action.methodName];
+                result = await method.apply(controllerInstance, event.parameters);
+            } else {
+                result = await event.route.action.fn(...event.parameters);
+            }
 
             if (isElementStruct(result)) {
                 const html = await getTemplateRender()(event.injectorContext.getRootInjector(), result, this.stopwatch ? this.stopwatch : undefined);
                 result = new HtmlResponse(html, 200).header('Content-Type', 'text/html; charset=utf-8');
             }
+            if (result instanceof stream.Readable) {
+                const stream = result as stream.Readable;
+                await new Promise((resolve, reject) => {
+                    stream.once('readable', resolve)
+                    stream.once('error', reject)
+                })
+            }
             const responseEvent = new HttpResponseEvent(event.injectorContext, event.request, event.response, result, event.route);
             responseEvent.controllerActionTime = Date.now() - start;
             event.next('response', responseEvent);
@@ -671,7 +740,7 @@ export class HttpListener {
         if (event.response.headersSent) return;
         if (event.result === undefined || event.result === null) return;
 
-        if (event.result instanceof HtmlResponse || event.result instanceof ServerResponse || event.result instanceof Redirect) {
+        if (event.result instanceof HtmlResponse || event.result instanceof ServerResponse || event.result instanceof Redirect || event.result instanceof stream.Readable) {
             // don't do anything
         } else if (event.result instanceof JSONResponse) {
             const schema = (event.result._statusCode && event.route.getSchemaForResponse(event.result._statusCode)) || event.route.returnType;
@@ -700,5 +769,9 @@ export class HttpListener {
         if (event.response.headersSent) return;
 
         this.resultFormatter.handle(event.result, event);
+        await new Promise((resolve, reject) => {
+            event.response.once('finish', resolve);
+            event.response.once('error', reject);
+        });
     }
 }

package/src/kernel.ts

@@ -1,5 +1,5 @@
 import { InjectorContext } from '@deepkit/injector';
-import { Router } from './router';
+import { HttpRouter } from './router';
 import { EventDispatcher } from '@deepkit/event';
 import { LoggerInterface } from '@deepkit/logger';
 import { HttpRequest, HttpResponse, MemoryHttpResponse, RequestBuilder } from './model';
@@ -9,7 +9,7 @@ import { unlink } from 'fs';
 
 export class HttpKernel {
     constructor(
-        protected router: Router,
+        protected router: HttpRouter,
         protected eventDispatcher: EventDispatcher,
         protected injectorContext: InjectorContext,
         protected logger: LoggerInterface,

package/src/model.ts

@@ -8,11 +8,12 @@
  * You should have received a copy of the MIT License along with this program.
  */
 
-import { IncomingMessage, ServerResponse } from 'http';
+import { IncomingMessage, OutgoingHttpHeader, OutgoingHttpHeaders, ServerResponse } from 'http';
 import { UploadedFile } from './router';
 import * as querystring from 'querystring';
 import { Writable } from 'stream';
 import { metaAnnotation, ReflectionKind, Type, ValidationErrorItem } from '@deepkit/type';
+import { isArray } from '@deepkit/core';
 
 export class HttpResponse extends ServerResponse {
     status(code: number) {
@@ -77,13 +78,14 @@ export type HttpQueries<T, Options extends { name?: string } = {}> = T & { __met
  * }
  * ```
  */
-export type HttpRegExp<T, Pattern extends string> = T & { __meta?: ['httpRegExp', Pattern] };
+export type HttpRegExp<T, Pattern extends string | RegExp> = T & { __meta?: ['httpRegExp', Pattern] };
 
-export function getRegExp(type: Type): string | undefined {
+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;
-    return options[0].literal;
+    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;
+    return;
 }
 
 export class RequestBuilder {
@@ -235,6 +237,34 @@ export class HttpRequest extends IncomingMessage {
 
 export class MemoryHttpResponse extends HttpResponse {
     public body: Buffer = Buffer.alloc(0);
+    public headers: {[name: string]: number | string | string[] | undefined} = Object.create(null);
+
+    setHeader(name: string, value: number | string | ReadonlyArray<string>): this {
+        this.headers[name] = value as any;
+        super.setHeader(name, value);
+        return this;
+    }
+
+    removeHeader(name: string) {
+        delete this.headers[name];
+        super.removeHeader(name);
+    }
+
+    getHeader(name: string) {
+        return this.headers[name];
+    }
+
+    getHeaders(): OutgoingHttpHeaders {
+        return this.headers;
+    }
+
+    writeHead(statusCode: number, headersOrReasonPhrase?: string | OutgoingHttpHeaders | OutgoingHttpHeader[], headers?: OutgoingHttpHeaders | OutgoingHttpHeader[]): this {
+        headers = typeof headersOrReasonPhrase === 'string' ? headers : headersOrReasonPhrase;
+        if (headers && !isArray(headers)) this.headers = headers;
+
+        if (typeof headersOrReasonPhrase === 'string') return super.writeHead(statusCode, headersOrReasonPhrase, headers);
+        return super.writeHead(statusCode, headers);
+    }
 
     get json(): any {
         const json = this.bodyString;
@@ -287,6 +317,5 @@ export class MemoryHttpResponse extends HttpResponse {
             this.body = Buffer.concat([this.body, chunk]);
         }
         return super.end(chunk, encoding, callback);
-        // if (callback) callback();
     }
 }

package/src/module.ts

@@ -1,7 +1,7 @@
 import { HttpListener, HttpResultFormatter, httpWorkflow } from './http';
 import { HttpConfig } from './module.config';
 import { AppModule, createModule } from '@deepkit/app';
-import { Router } from './router';
+import { HttpRouter, HttpRouterRegistry } from './router';
 import { HttpKernel } from './kernel';
 import { HttpRouterFilterResolver } from './filter';
 import { HttpControllers } from './controllers';
@@ -14,9 +14,10 @@ import { httpClass } from './decorator';
 export class HttpModule extends createModule({
     config: HttpConfig,
     providers: [
-        Router,
+        HttpRouter,
         HttpKernel,
         HttpResultFormatter,
+        HttpRouterRegistry,
         HttpRouterFilterResolver,
         { provide: HttpResponse, scope: 'http' },
         { provide: HttpRequest, scope: 'http' },
@@ -29,7 +30,8 @@ export class HttpModule extends createModule({
         httpWorkflow
     ],
     exports: [
-        Router,
+        HttpRouter,
+        HttpRouterRegistry,
         HttpKernel,
         HttpResultFormatter,
         HttpRouterFilterResolver,