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

package/src/kernel.ts

@@ -1,103 +1,151 @@
-import { inject, injectable, InjectorContext, MemoryInjector } from '@deepkit/injector';
-import { Router } from './router';
+import { InjectorContext } from '@deepkit/injector';
+import { HttpRouter } from './router.js';
 import { EventDispatcher } from '@deepkit/event';
-import { Logger } from '@deepkit/logger';
-import { HttpRequest, HttpResponse } from './model';
-import { Socket } from 'net';
-import { HttpRequestEvent, httpWorkflow } from './http';
-import { config } from './module.config';
+import { LoggerInterface } from '@deepkit/logger';
+import {
+    HttpRequest,
+    HttpResponse,
+    incomingMessageToHttpRequest,
+    MemoryHttpResponse,
+    RequestBuilder,
+    serverResponseToHttpResponse,
+} from './model.js';
+import { HttpError, HttpRequestEvent, HttpResultFormatter, httpWorkflow, JSONResponse } from './http.js';
+import { FrameCategory, Stopwatch } from '@deepkit/stopwatch';
+import { unlink } from 'fs';
+import { ValidationError } from '@deepkit/type';
+import { IncomingMessage, ServerResponse } from 'http';
 
+interface HttpKernelHandleOptions {
+    /**
+     * Makes the kernel throw a HttpNotFoundError when the route is not found
+     * or a controller threw a HttpNotFoundError. This allows you to catch
+     * the error and handle it yourself.
+     */
+    throwOnNotFound?: boolean;
+}
+
+interface HttpKernelMiddlewareOptions extends HttpKernelHandleOptions {
+    /**
+     * If true, a HttpNotFoundError or missing route is not automatically
+     * sent to the client. Instead, the request is passed to the next middleware.
+     */
+    fallThroughOnNotFound?: boolean;
+}
 
-@injectable()
 export class HttpKernel {
     constructor(
-        protected router: Router,
+        protected router: HttpRouter,
         protected eventDispatcher: EventDispatcher,
         protected injectorContext: InjectorContext,
-        protected logger: Logger,
-        @inject(config.token('debug')) protected debug: boolean = false,
+        protected logger: LoggerInterface,
+        protected stopwatch?: Stopwatch,
     ) {
-
     }
 
-    async handleRequestFor(method: string, url: string, jsonBody?: any): Promise<any> {
-        const body = Buffer.from(jsonBody ? JSON.stringify(jsonBody) : '');
+    /**
+     * Creates a request handler function that can be used with http.createServer
+     * or any other http server library based on the node.js http module.
+     *
+     * When `fallThroughOnNotFound` is set to true, the handler will call `next()`
+     * when the route is not found, allowing the request to fall through to the next
+     * middleware in the chain.
+     *
+     * @example
+     * ```typescript
+     * import { createServer } from 'http';
+     *
+     * const app = new App({
+     *   imports: [new HttpModule({})],
+     * });
+     *
+     * const handler = app.get(HttpKernel).createMiddleware({ fallThroughOnNotFound: true });
+     * const server = createServer(handler);
+     *
+     * server.listen(3000);
+     * ```
+     */
+    public createMiddleware(options: HttpKernelMiddlewareOptions = {}) {
+        if (options.fallThroughOnNotFound && 'undefined' === typeof options.throwOnNotFound) {
+            options.throwOnNotFound = true;
+        }
+        return (req: IncomingMessage, res: ServerResponse, next: (error?: any) => void) => {
+            return this.handleRequest(req, res, options).then(() => {
+                next();
+            }).catch((error) => {
+                if (options.fallThroughOnNotFound && error instanceof HttpError && error.httpCode === 404) {
+                    next();
+                    return;
+                }
+                next(error);
+            });
+        };
+    }
 
-        const request = new (class extends HttpRequest {
-            url = url;
-            method = method;
-            position = 0;
+    public async request(requestBuilder: RequestBuilder, options: HttpKernelHandleOptions = {}): Promise<MemoryHttpResponse> {
+        const request = requestBuilder.build();
+        const response = new MemoryHttpResponse(request);
+        response.assignSocket(request.socket);
+        await this.handleRequest(request, response, options);
+        return response;
+    }
 
-            headers = {
-                'content-type': 'application/json',
-                'content-length': String(body.byteLength),
-            };
+    async handleRequest(
+        _req: IncomingMessage,
+        _res: ServerResponse,
+        options: HttpKernelHandleOptions = {},
+    ): Promise<void> {
+        const httpInjectorContext = this.injectorContext.createChildScope('http');
+        const req = incomingMessageToHttpRequest(_req);
+        const res = serverResponseToHttpResponse(_res);
+        httpInjectorContext.set(HttpRequest, req);
+        httpInjectorContext.set(HttpResponse, res);
+        httpInjectorContext.set(InjectorContext, httpInjectorContext);
+        req.throwErrorOnNotFound = options.throwOnNotFound || false;
 
-            done = false;
+        const frame = this.stopwatch ? this.stopwatch.start(req.method + ' ' + req.getUrl(), FrameCategory.http, true) : undefined;
+        const workflow = httpWorkflow.create('start', this.eventDispatcher, httpInjectorContext, this.stopwatch);
 
-            _read(size: number) {
-                if (this.done) {
-                    this.push(null);
-                } else {
-                    this.push(body);
-                    this.done = true;
-                }
+        try {
+            if (frame) {
+                frame.data({ url: req.getUrl(), method: req.getMethod(), clientIp: req.getRemoteAddress() });
+                await frame.run(() => workflow.apply('request', new HttpRequestEvent(httpInjectorContext, req, res)));
+            } else {
+                await workflow.apply('request', new HttpRequestEvent(httpInjectorContext, req, res));
             }
-        })(new Socket());
+        } catch (error: any) {
+            if (!res.headersSent) {
+                const resultFormatter = httpInjectorContext.get(HttpResultFormatter);
+                if (error instanceof ValidationError) {
+                    resultFormatter.handle(new JSONResponse({
+                        message: error.message,
+                        errors: error.errors,
+                    }, 400).disableAutoSerializing(), { request: req, response: res });
+                    return;
+                } else if (error instanceof HttpError) {
+                    if (req.throwErrorOnNotFound && error.httpCode === 404) {
+                        throw error;
+                    }
+                    resultFormatter.handle(new JSONResponse({
+                        message: error.message,
+                    }, error.httpCode).disableAutoSerializing(), { request: req, response: res });
+                    return;
+                }
 
-        let result: any = 'nothing';
-        const response = new (class extends HttpResponse {
-            end(chunk: any) {
-                result = chunk ? chunk.toString() : chunk;
+                res.status(500);
             }
 
-            write(chunk: any): boolean {
-                result = chunk ? chunk.toString() : chunk;
-                return true;
+            this.logger.error('HTTP kernel request failed', error);
+        } finally {
+            for (const file of Object.values(req.uploadedFiles || [])) {
+                unlink(file.path, () => {
+                });
             }
-        })(request);
-
-        await this.handleRequest(request, response);
-        if (result === '' || result === undefined || result === null) return result;
-        try {
-            return JSON.parse(result);
-        } catch (error) {
-            return result;
-        }
-    }
-
-    async handleRequest(req: HttpRequest, res: HttpResponse) {
-        const httpInjectorContext = this.injectorContext.createChildScope('http', new MemoryInjector([
-            { provide: HttpRequest, useValue: req },
-            { provide: HttpResponse, useValue: res },
-        ]));
 
-        //todo: How should we do that?
-        // const collector = this.debug ? httpInjectorContext.get(HttpRequestDebugCollector) : undefined;
-
-        // const workflow = httpWorkflow.create('start', this.eventDispatcher, httpInjectorContext, collector?.stopwatch);
-        const workflow = httpWorkflow.create('start', this.eventDispatcher, httpInjectorContext);
-
-        try {
-            // if (collector) {
-            //     await collector.init();
-            //     try {
-            //         collector.stopwatch.start('http');
-            //
-            //         //todo: How should we do that?
-            //         await Zone.run({ collector: collector }, async () => {
-            //             await workflow.apply('request', new HttpRequestEvent(httpInjectorContext, req, res));
-            //         });
-            //         collector.stopwatch.end('http');
-            //     } finally {
-            //         await collector.save();
-            //     }
-            // } else {
-                await workflow.apply('request', new HttpRequestEvent(httpInjectorContext, req, res));
-            // }
-        } catch (error) {
-            this.logger.error('HTTP kernel request failed', error);
-            throw error;
+            if (frame) {
+                frame.data({ responseStatus: res.statusCode });
+                frame.end();
+            }
         }
     }
 }

package/src/logger.ts

@@ -1,17 +1,15 @@
-import { injectable } from '@deepkit/injector';
-import { Logger } from '@deepkit/logger';
+import { LoggerInterface } from '@deepkit/logger';
 import { eventDispatcher } from '@deepkit/event';
-import { httpWorkflow } from './http';
+import { httpWorkflow } from './http.js';
 
-@injectable()
 export class HttpLogger {
-    constructor(private logger: Logger) {
+    constructor(private logger: LoggerInterface) {
     }
 
     @eventDispatcher.listen(httpWorkflow.onResponse, 101) //101 is right after 100 default listener
     onHttpRequest(event: typeof httpWorkflow.onResponse.event) {
         this.logger.log(
-            event.request.connection.remoteAddress, '-',
+            event.request.connection.remoteAddress || '0.0.0.0', '-',
             event.request.method,
             `"${event.request.url}"`,
             event.response.statusCode,

package/src/middleware.ts

@@ -0,0 +1,116 @@
+import { ClassType, isClass } from '@deepkit/core';
+import { AppModule } from '@deepkit/app';
+import { createFreeDecoratorContext } from '@deepkit/type';
+import { HttpRequest, HttpResponse } from './model.js';
+import { InjectorModule } from '@deepkit/injector';
+
+export type HttpMiddlewareFn = (req: HttpRequest, res: HttpResponse, next: (err?: any) => void) => void | Promise<void>;
+
+export interface HttpMiddleware {
+    execute: HttpMiddlewareFn;
+}
+
+export interface HttpMiddlewareRoute {
+    path?: string;
+    pathRegExp?: RegExp;
+    httpMethod?: 'GET' | 'HEAD' | 'POST' | 'PATCH' | 'PUT' | 'DELETE' | 'OPTIONS' | 'TRACE';
+    category?: string;
+    excludeCategory?: string;
+    group?: string;
+    excludeGroup?: string;
+}
+
+export class HttpMiddlewareConfig {
+    name?: string;
+    middlewares: (HttpMiddlewareFn | ClassType<HttpMiddleware>)[] = [];
+
+    routes: HttpMiddlewareRoute[] = [];
+    excludeRoutes: HttpMiddlewareRoute[] = [];
+
+    order: number = 0;
+
+    controllers: ClassType[] = [];
+    excludeControllers: ClassType[] = [];
+
+    routeNames: string[] = [];
+    excludeRouteNames: string[] = [];
+
+    timeout?: number;
+
+    modules: InjectorModule<any>[] = [];
+
+    selfModule: boolean = false;
+
+    getClassTypes(): ClassType[] {
+        const classTypes: ClassType[] = [];
+        for (const middleware of this.middlewares) {
+            if (isClass(middleware)) classTypes.push(middleware);
+        }
+
+        return classTypes;
+    }
+}
+
+export class HttpMiddlewareApi {
+    t = new HttpMiddlewareConfig;
+
+    name(name: string) {
+        this.t.name = name;
+    }
+
+    for(...middlewares: (HttpMiddlewareFn | ClassType<HttpMiddleware>)[]) {
+        this.t.middlewares = middlewares;
+    }
+
+    forRoutes(...routes: HttpMiddlewareRoute[]) {
+        this.t.routes = routes;
+    }
+
+    excludeRoutes(...routes: HttpMiddlewareRoute[]) {
+        this.t.excludeRoutes = routes;
+    }
+
+    forRouteNames(...names: string[]) {
+        this.t.routeNames = names;
+    }
+
+    excludeRouteNames(...names: string[]) {
+        this.t.excludeRouteNames = names;
+    }
+
+    /**
+     * When the middleware does not respond (either calling next() or sending headers) withing <timeout> milliseconds,
+     * automatically the next is executed and warning printed.
+     */
+    timeout(timeout: number) {
+        this.t.timeout = timeout;
+    }
+
+    forControllers(...controllers: ClassType[]) {
+        this.t.controllers = controllers;
+    }
+
+    excludeControllers(...controllers: ClassType[]) {
+        this.t.excludeControllers = controllers;
+    }
+
+    /**
+     * Per default middlewares are executed in the order they were registered. The default order is 0. A lower order means the middleware is executed earlier.
+     */
+    order(order: number) {
+        this.t.order = order;
+    }
+
+    forModules(...modules: AppModule<any>[]) {
+        this.t.modules = modules;
+    }
+
+    /**
+     * Limit the middleware to the module where this middleware is defined.
+     */
+    forSelfModules() {
+        this.t.selfModule = true;
+    }
+}
+
+export const httpMiddleware = createFreeDecoratorContext(HttpMiddlewareApi);