@deepkit/http 1.0.1-alpha.100

package/src/kernel.ts

@@ -0,0 +1,79 @@
+import { InjectorContext } from '@deepkit/injector';
+import { HttpRouter } from './router.js';
+import { EventDispatcher } from '@deepkit/event';
+import { LoggerInterface } from '@deepkit/logger';
+import { HttpRequest, HttpResponse, MemoryHttpResponse, RequestBuilder } 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';
+
+export class HttpKernel {
+    constructor(
+        protected router: HttpRouter,
+        protected eventDispatcher: EventDispatcher,
+        protected injectorContext: InjectorContext,
+        protected logger: LoggerInterface,
+        protected stopwatch?: Stopwatch,
+    ) {
+
+    }
+
+    public async request(requestBuilder: RequestBuilder): Promise<MemoryHttpResponse> {
+        const request = requestBuilder.build();
+        const response = new MemoryHttpResponse(request);
+        response.assignSocket(request.socket);
+        await this.handleRequest(request, response);
+        return response;
+    }
+
+    async handleRequest(req: HttpRequest, res: HttpResponse) {
+        const httpInjectorContext = this.injectorContext.createChildScope('http');
+        httpInjectorContext.set(HttpRequest, req);
+        httpInjectorContext.set(HttpResponse, res);
+        httpInjectorContext.set(InjectorContext, httpInjectorContext);
+
+        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);
+
+        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));
+            }
+        } 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) {
+                    resultFormatter.handle(new JSONResponse({
+                        message: error.message
+                    }, error.httpCode).disableAutoSerializing(), { request: req, response: res });
+                    return;
+                }
+
+                res.status(500);
+            }
+
+            this.logger.error('HTTP kernel request failed', error);
+        } finally {
+            for (const file of Object.values(req.uploadedFiles)) {
+                unlink(file.path, () => {
+                });
+            }
+
+            if (frame) {
+                frame.data({ responseStatus: res.statusCode });
+                frame.end();
+            }
+        }
+    }
+}

package/src/logger.ts

@@ -0,0 +1,20 @@
+import { LoggerInterface } from '@deepkit/logger';
+import { eventDispatcher } from '@deepkit/event';
+import { httpWorkflow } from './http.js';
+
+export class HttpLogger {
+    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 || '0.0.0.0', '-',
+            event.request.method,
+            `"${event.request.url}"`,
+            event.response.statusCode,
+            `"${event.request.headers.referer || ''}"`,
+            // `"${event.request.headers['user-agent']}"`,
+        );
+    }
+}

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);

package/src/model.ts

@@ -0,0 +1,392 @@
+/*
+ * Deepkit Framework
+ * Copyright (C) 2021 Deepkit UG, Marc J. Schmidt
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the MIT License.
+ *
+ * You should have received a copy of the MIT License along with this program.
+ */
+
+import { IncomingMessage, OutgoingHttpHeader, OutgoingHttpHeaders, ServerResponse } from 'http';
+import { UploadedFile } from './router.js';
+import * as querystring from 'querystring';
+import { Writable } from 'stream';
+import { metaAnnotation, ReflectionKind, Type, ValidationErrorItem } from '@deepkit/type';
+import { asyncOperation, isArray } from '@deepkit/core';
+
+export class HttpResponse extends ServerResponse {
+    status(code: number) {
+        this.writeHead(code);
+        this.end();
+    }
+}
+
+/**
+ * Reads the body of the request and returns it as a Buffer.
+ * The result will be cached in the request object as `request.body`.
+ *
+ * Deepkit's router will automatically use `request.body` if available.
+ */
+export function readBody(request: IncomingMessage): Promise<Buffer> {
+    return asyncOperation((resolve, reject) => {
+        const chunks: Buffer[] = [];
+        request.on('data', (chunk: Buffer) => {
+            chunks.push(chunk);
+        });
+        request.on('end', () => {
+            const body = Buffer.concat(chunks);
+            //the router uses this now instead of trying to read the body again
+            (request as HttpRequest).body = body;
+            resolve(body);
+        });
+        request.on('error', (error: Error) => {
+            reject(error);
+        });
+    });
+}
+
+export function createRequestWithCachedBody(request: Partial<IncomingMessage>, body: Buffer): HttpRequest {
+    const headers = request.headers;
+    const method = request.method;
+    const url = request.url;
+
+    const writable = new Writable({
+        write(chunk, encoding, callback) {
+            callback();
+        },
+        writev(chunks, callback) {
+            callback();
+        }
+    });
+    return new (class extends HttpRequest {
+        url = url;
+        method = method;
+        position = 0;
+
+        headers = headers as any;
+
+        _read(size: number) {
+            if (this.complete) {
+                this.push(null);
+            } else {
+                //in Node 18 this seems to be necessary to not trigger the abort event
+                this.complete = true;
+                this.push(body);
+            }
+        }
+    })(writable as any);
+}
+
+export type HttpRequestQuery = { [name: string]: string };
+export type HttpRequestResolvedParameters = { [name: string]: any };
+export type HttpRequestPositionedParameters = { arguments: any[], parameters: HttpRequestResolvedParameters };
+
+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 HttpPath<T, Options extends { name?: string } = {}> = T & { __meta?: ['httpPath', Options] };
+export type HttpHeader<T, Options extends { name?: string } = {}> = T & { __meta?: ['httpHeader', Options] };
+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 | RegExp> = T & { __meta?: ['httpRegExp', Pattern] };
+
+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 options[0].literal;
+    if (options[0].kind === ReflectionKind.literal && options[0].literal instanceof RegExp) return options[0].literal;
+    return;
+}
+
+export class RequestBuilder {
+    protected contentBuffer: Buffer = Buffer.alloc(0);
+    protected _headers: { [name: string]: string } = {};
+    protected queryPath?: string;
+
+    constructor(
+        protected path: string,
+        protected method: string = 'GET',
+    ) {
+    }
+
+    getUrl() {
+        if (this.queryPath) {
+            return this.path + '?' + this.queryPath;
+        }
+        return this.path;
+    }
+
+    build(): HttpRequest {
+        return createRequestWithCachedBody({
+            method: this.method,
+            url: this.getUrl(),
+            headers: this._headers,
+        }, this.contentBuffer);
+    }
+
+    headers(headers: { [name: string]: string }): this {
+        this._headers = headers;
+        return this;
+    }
+
+    header(name: string, value: string | number): this {
+        this._headers[name] = String(value);
+        return this;
+    }
+
+    json(body: object): this {
+        this.contentBuffer = Buffer.from(JSON.stringify(body), 'utf8');
+        this._headers['content-type'] = 'application/json; charset=utf-8';
+        this._headers['content-length'] = String(this.contentBuffer.byteLength);
+        return this;
+    }
+
+    multiPart(items: { name: string, file?: Uint8Array, fileName?: string, json?: any }[]): this {
+        const boundary = '--------------------------' + Math.random().toString(36).substr(2, 10);
+        this._headers['content-type'] = 'multipart/form-data; boundary=' + boundary;
+        const parts = items.map(item => {
+            if (item.file) {
+                const header = Buffer.from(`--${boundary}\r
+Content-Disposition: form-data; name="${item.name}"; filename="${item.fileName || 'file'}"\r
+Content-Type: application/octet-stream\r
+\r\n`, 'utf8');
+                return Buffer.concat([header, item.file, Buffer.from('\r\n', 'utf8')]);
+            } else if (item.json) {
+                const header = Buffer.from(`--${boundary}\r
+Content-Disposition: form-data; name="${item.name}"\r
+Content-Type: application/json\r
+\r\n`, 'utf8');
+                return Buffer.concat([header, Buffer.from(JSON.stringify(item.json) + '\r\n', 'utf8')]);
+            } else {
+                throw new Error('Invalid multiPart item');
+            }
+        });
+        parts.push(Buffer.from(`--${boundary}--`, 'utf8'));
+        this.contentBuffer = Buffer.concat(parts);
+        this._headers['content-length'] = String(this.contentBuffer.byteLength);
+        return this;
+    }
+
+    body(body: string | Buffer): this {
+        if ('string' === typeof body) {
+            this.contentBuffer = Buffer.from(body, 'utf8');
+        } else {
+            this.contentBuffer = body;
+        }
+        this._headers['content-length'] = String(this.contentBuffer.byteLength);
+        return this;
+    }
+
+    query(query: any): this {
+        this.queryPath = querystring.stringify(query);
+        return this;
+    }
+}
+
+export class HttpRequest extends IncomingMessage {
+    /**
+     * A store that can be used to transport data from guards/listeners to ParameterResolvers/controllers.
+     */
+    public store: { [name: string]: any } = {};
+
+    public uploadedFiles: { [name: string]: UploadedFile } = {};
+
+    /**
+     * The router sets the body when it was read.
+     */
+    public body?: Buffer;
+
+    async readBody(): Promise<Buffer> {
+        if (this.body) return this.body;
+        return await readBody(this);
+    }
+
+    async readBodyText(): Promise<string> {
+        return (await this.readBody()).toString('utf8');
+    }
+
+    static GET(path: string): RequestBuilder {
+        return new RequestBuilder(path);
+    }
+
+    static POST(path: string): RequestBuilder {
+        return new RequestBuilder(path, 'POST');
+    }
+
+    static OPTIONS(path: string): RequestBuilder {
+        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');
+    }
+
+    static PUT(path: string): RequestBuilder {
+        return new RequestBuilder(path, 'PUT');
+    }
+
+    static DELETE(path: string): RequestBuilder {
+        return new RequestBuilder(path, 'DELETE');
+    }
+
+    getUrl(): string {
+        return this.url || '/';
+    }
+
+    getMethod(): string {
+        return this.method || 'GET';
+    }
+
+    getRemoteAddress(): string {
+        return this.socket.remoteAddress || '';
+    }
+}
+
+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;
+        try {
+            return JSON.parse(json);
+        } catch (error: any) {
+            throw new Error(`Could not parse JSON: ${error.message}, body: ${json}`);
+        }
+    }
+
+    get text(): string {
+        return this.bodyString;
+    }
+
+    get bodyString(): string {
+        return this.body.toString('utf8');
+    }
+
+    write(
+        chunk: any,
+        encoding: any,
+        callback?: any
+    ): any {
+        if (typeof encoding === 'function') {
+            callback = encoding;
+            encoding = null;
+        }
+
+        if (chunk) {
+            if ('string' === typeof chunk) {
+                chunk = Buffer.from(chunk, encoding || 'utf8');
+            }
+            this.body = Buffer.concat([this.body, chunk]);
+        }
+
+        if (callback) callback();
+        return true;
+    }
+
+    end(chunk: any, encoding?: any, callback?: any): any {
+        if (typeof chunk === 'function') {
+            callback = chunk;
+            chunk = null;
+            encoding = null;
+        } else if (typeof encoding === 'function') {
+            callback = encoding;
+            encoding = null;
+        }
+
+        if (chunk) {
+            if ('string' === typeof chunk) {
+                chunk = Buffer.from(chunk, encoding || 'utf8');
+            }
+            this.body = Buffer.concat([this.body, chunk]);
+        }
+        this.emit('finish');
+        super.end(chunk, encoding, callback);
+        this.emit('close');
+        return this;
+    }
+}

package/src/module.config.ts

@@ -0,0 +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 = {};
+}