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

package/dist/esm/src/middleware.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware.js","sourceRoot":"","sources":["../../../src/middleware.ts"],"names":[],"mappings":"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"}

package/dist/esm/src/model.d.ts

@@ -1,14 +1,232 @@
-/// <reference types="node" />
-import { IncomingMessage, ServerResponse } from 'http';
+import { IncomingMessage, OutgoingHttpHeader, OutgoingHttpHeaders, ServerResponse } from 'http';
+import { UploadedFile } from './router.js';
+import { Type, ValidationErrorItem } from '@deepkit/type';
+import { TypeAnnotation } from '@deepkit/core';
 export declare class HttpResponse extends ServerResponse {
     status(code: number): void;
 }
-export declare type HttpRequestQuery = {
+/**
+ * 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 declare function readBody(request: IncomingMessage): Promise<Buffer>;
+export declare function createRequestWithCachedBody(request: Partial<IncomingMessage>, body: Buffer): HttpRequest;
+export type HttpRequestQuery = {
     [name: string]: string;
 };
-export declare type HttpRequestResolvedParameters = {
+export type HttpRequestResolvedParameters = {
     [name: string]: any;
 };
+export type HttpRequestPositionedParameters = {
+    arguments: any[];
+    parameters: HttpRequestResolvedParameters;
+};
+export declare class BodyValidationError {
+    readonly errors: ValidationErrorItem[];
+    constructor(errors?: ValidationErrorItem[]);
+    hasErrors(prefix?: string): boolean;
+    getErrors(prefix?: string): ValidationErrorItem[];
+    getErrorsForPath(path: string): ValidationErrorItem[];
+    getErrorMessageForPath(path: string): string;
+}
+export declare class ValidatedBody<T> {
+    error: BodyValidationError;
+    value?: T | undefined;
+    constructor(error: BodyValidationError, value?: T | undefined);
+    valid(): this is {
+        value: T;
+    };
+}
+/**
+ * Marks a parameter as HTTP body and reads the value from the request body.
+ *
+ * @example
+ * ```typescript
+ * class Controller {
+ *   @http.GET('/api')
+ *   route(body: HttpBody<{username: string}>) {
+ *     //body is {username: string} and required
+ *     //could also reference an interface or type alias via `HttpBody<MyInterface>`
+ *   }
+ * }
+ *
+ * // curl /api -d '{"username":"Peter"}'
+ */
+export type HttpBody<T> = T & TypeAnnotation<'httpBody'>;
+export type HttpBodyValidation<T> = ValidatedBody<T> & TypeAnnotation<'httpBodyValidation'>;
+export interface HttpRequestParserOptions {
+    withPath?: boolean;
+    withBody?: boolean;
+    withQuery?: boolean;
+    withHeader?: boolean;
+}
+/**
+ * Delays the parsing of the path/body/query/header to the very last moment, when the parameter is actually used.
+ *
+ * If no options are provided, the parser will receive data from path, header, body, and query, in this order.
+ * This basically allows to fetch data from all possible HTTP sources in one go.
+ *
+ * You can disable various sources by providing the options, e.g. `{withBody: false}` to disable body parsing.
+ * Or `{withQuery: false}` to disable query parsing. Or `{withHeader: false}` to disable header parsing.
+ * To only parse the body, use `{withQuery: false, withHeader: false}`.
+ *
+ * @example
+ * ```typescript
+ * async route(parser: HttpRequestParser<{authorization: string}>) {
+ *    const data = await parser();
+ *    console.log(data.authorization);
+ * }
+ * ```
+ *
+ * Note that the parsers is based on all defined parameters (e.g. `userId: HttpQuery<string>` => {userId: string}),
+ * and then starts from there applying header, body, and then query values.
+ * This means you also get access to defined path parameters, like:
+ *
+ * ```typescript
+ * @http.GET('teams/:teamId')
+ * async route(teamId: string) {
+ *    //teamId is string
+ * }
+ *
+ * httpWorkflow.onController.listen((event, parser: HttpRequestParser<{teamId: string}>) => {
+ *  const data = await parser();
+ *  console.log(data.teamId);
+ * });
+ * ```
+ *
+ * HttpRequestParser is necessary in event listeners, since they are instantiated synchronously,
+ * but body is parsed asynchronously. So use in event listeners HttpRequestParser instead of HttpBody.
+ */
+export type HttpRequestParser<T> = ((options?: HttpRequestParserOptions) => Promise<T>) & TypeAnnotation<'httpRequestParser', T>;
+/**
+ * Marks a parameter as HTTP path and reads the value from the request path.
+ * This is normally not requires since the parameter name automatically maps to the path parameter,
+ * but in case of requesting the path parameter in for example listeners, this is required.
+ * The name option can be used to change the parameter name.
+ *
+ * @example
+ * ```typescript
+ * app.listen(httpWorkflow.onController, (event, request: HttpRequest, groupId: HttpPath<number>) => {
+ *   console.log(groupId); //123
+ * });
+ *
+ * class Controller {
+ *   @http.GET('/api/:groupId')
+ *   route(groupId: number) {
+ *     //groupId is number and required
+ *     //same as `groupId: HttpPath<number>`
+ *   }
+ * }
+ * ```
+ */
+export type HttpPath<T, Options extends {
+    name?: string;
+} = {}> = T & TypeAnnotation<'httpPath', Options>;
+/**
+ * Marks a parameter as HTTP header and reads the value from the request header.
+ *
+ * @example
+ * ```typescript
+ * class Controller {
+ *    @http.GET('/api')
+ *    route(authorization: HttpHeader<string>) {
+ *         //authorization is string and required
+ *         //use `authorization?: HttpHeader<string>` to make it optional
+ *    }
+ * }
+ *
+ * // curl /api -H 'Authorization: 123'
+ * ```
+ *
+ * To change the header name, use `param: HttpHeader<string, {name: 'X-My-Header'}>`.
+ */
+export type HttpHeader<T, Options extends {
+    name?: string;
+} = {}> = T & TypeAnnotation<'httpHeader', Options>;
+/**
+ * Marks a parameter as HTTP query and reads the value from the request query string.
+ *
+ * @example
+ * ```typescript
+ * class Controller {
+ *   @http.GET('/api')
+ *   route(limit: HttpQuery<number>) {
+ *      //limit is number and required
+ *      //use `limit?: HttpQuery<number>` to make it optional
+ *   }
+ * }
+ *
+ * // curl /api?limit=10
+ * ```
+ */
+export type HttpQuery<T, Options extends {
+    name?: string;
+} = {}> = T & TypeAnnotation<'httpQuery', Options>;
+/**
+ * Marks a parameter as HTTP query objects and reads multiple values from the request query string into an object.
+ *
+ * @example
+ * ```typescript
+ * interface Query {
+ *    limit?: number;
+ *    offset?: number;
+ *    sort?: 'asc' | 'desc';
+ * }
+ *
+ * class Controller {
+ *  @http.GET('/api')
+ *  route(query: HttpQueries<Query>) {
+ *    //query is an object containing limit, offset, and sort
+ * }
+ *
+ * // curl /api?limit=10&offset=20&sort=asc
+ */
+export type HttpQueries<T, Options extends {
+    name?: string;
+} = {}> = T & TypeAnnotation<'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 & TypeAnnotation<'httpRegExp', Pattern>;
+export declare function getRegExp(type: Type): string | RegExp | undefined;
+export declare class RequestBuilder {
+    protected path: string;
+    protected method: string;
+    protected contentBuffer: Buffer;
+    protected _headers: {
+        [name: string]: string;
+    };
+    protected queryPath?: string;
+    constructor(path: string, method?: string);
+    getUrl(): string;
+    build(): HttpRequest;
+    headers(headers: {
+        [name: string]: string;
+    }): this;
+    header(name: string, value: string | number): this;
+    json(body: object): this;
+    multiPart(items: {
+        name: string;
+        file?: Uint8Array;
+        fileName?: string;
+        json?: any;
+    }[]): this;
+    body(body: string | Buffer): this;
+    query(query: any | string): this;
+}
 export declare class HttpRequest extends IncomingMessage {
     /**
      * A store that can be used to transport data from guards/listeners to ParameterResolvers/controllers.
@@ -16,7 +234,55 @@ export declare class HttpRequest extends IncomingMessage {
     store: {
         [name: string]: any;
     };
+    uploadedFiles: {
+        [name: string]: UploadedFile;
+    };
+    throwErrorOnNotFound: boolean;
+    /**
+     * The router sets the body when it was read.
+     */
+    body?: Buffer;
+    readBody(): Promise<Buffer>;
+    readBodyText(): Promise<string>;
+    static GET(path: string): RequestBuilder;
+    static POST(path: string): RequestBuilder;
+    static OPTIONS(path: string): RequestBuilder;
+    static TRACE(path: string): RequestBuilder;
+    static HEAD(path: string): RequestBuilder;
+    static PATCH(path: string): RequestBuilder;
+    static PUT(path: string): RequestBuilder;
+    static DELETE(path: string): RequestBuilder;
     getUrl(): string;
     getMethod(): string;
     getRemoteAddress(): string;
 }
+export declare function incomingMessageToHttpRequest(request: IncomingMessage): HttpRequest;
+export declare function serverResponseToHttpResponse(response: ServerResponse): HttpResponse;
+export declare class MemoryHttpResponse extends HttpResponse {
+    body: Buffer;
+    headers: {
+        [name: string]: number | string | string[] | undefined;
+    };
+    setHeader(name: string, value: number | string | ReadonlyArray<string>): this;
+    removeHeader(name: string): void;
+    getHeader(name: string): string | number | string[] | undefined;
+    getHeaders(): OutgoingHttpHeaders;
+    writeHead(statusCode: number, headersOrReasonPhrase?: string | OutgoingHttpHeaders | OutgoingHttpHeader[], headers?: OutgoingHttpHeaders | OutgoingHttpHeader[]): this;
+    get json(): any;
+    get text(): string;
+    get bodyString(): string;
+    write(chunk: any, encoding: any, callback?: any): any;
+    end(chunk: any, encoding?: any, callback?: any): any;
+}
+export declare type __ΩHttpRequestQuery = any[];
+export declare type __ΩHttpRequestResolvedParameters = any[];
+export declare type __ΩHttpRequestPositionedParameters = any[];
+export declare type __ΩHttpBody = any[];
+export declare type __ΩHttpBodyValidation = any[];
+export declare type __ΩHttpRequestParserOptions = any[];
+export declare type __ΩHttpRequestParser = any[];
+export declare type __ΩHttpPath = any[];
+export declare type __ΩHttpHeader = any[];
+export declare type __ΩHttpQuery = any[];
+export declare type __ΩHttpQueries = any[];
+export declare type __ΩHttpRegExp = any[];

package/dist/esm/src/model.js

@@ -1,3 +1,13 @@
+const __ΩError = ['name', 'message', 'stack', 'Error', 'P&4!&4"&4#8Mw$y'];
+const __ΩPartial = ['T', 'Partial', 'l+e#!e"!fRb!Pde"!gN#"w"y'];
+const __ΩReadonlyArray = ['T', 'length', 'toString', 'toLocaleString', () => __ΩConcatArray, 'items', 'concat', () => __ΩConcatArray, 'separator', 'join', 'start', 'end', 'slice', 'searchElement', 'fromIndex', 'indexOf', 'lastIndexOf', 'value', 'index', 'array', '', 'predicate', 'thisArg', 'every', 'some', 'callbackfn', 'forEach', 'map', 'filter', 'previousValue', 'currentValue', 'currentIndex', 'reduce', 'initialValue', 'reduceRight', 'ReadonlyArray', 'b!P\'4"9P&1#P&1$Pe#!o%"@2&e#!F1\'PPe$!e$!o("J@2&e#!F1\'P&2)8&1*P\'2+8\'2,8e#!F1-Pe#!2.\'2/8\'10Pe#!2.\'2/8\'11PPe$!22\'23e$!F924!/526"278!18PPe$!22\'23e$!F924#/526"278)18PPe$!22\'23e$!F924#/526"278)19PPe$!22\'23e$!F924$/52:"278$1;PPe$!22\'23e$!F924"/52:"278"F1<PPe$!22\'23e$!F924!/526"278"F1=PPe$!22\'23e$!F924#/526"278e#!F1=PPe$!2>e$!2?\'2@e$!F924e$!/52:e#!1APPe$!2>e$!2?\'2@e$!F924e$!/52:e#!2Be#!1APP"2>e$!2?\'2@e$!F924"/52:"2B"1APPe$!2>e$!2?\'2@e$!F924e$!/52:e#!1CPPe$!2>e$!2?\'2@e$!F924e$!/52:e#!2Be#!1CPP"2>e$!2?\'2@e$!F924"/52:"2B"1C\'e"!LMwDy'];
+const __ΩConcatArray = ['T', 'length', 'separator', 'join', 'start', 'end', 'slice', 'ConcatArray', 'b!P\'4"9\'e"!LP&2#8&1$P\'2%8\'2&8e#!F1\'Mw(y'];
+/*@ts-ignore*/
+import { __ΩTypeAnnotation } from '@deepkit/core';
+function __assignType(fn, args) {
+    fn.__type = args;
+    return fn;
+}
 /*
  * Deepkit Framework
  * Copyright (C) 2021 Deepkit UG, Marc J. Schmidt
@@ -8,12 +18,225 @@
  * You should have received a copy of the MIT License along with this program.
  */
 import { IncomingMessage, ServerResponse } from 'http';
+import { UploadedFile } from './router.js';
+import * as querystring from 'querystring';
+import { Writable } from 'stream';
+import { ReflectionKind, typeAnnotation, ValidationErrorItem } from '@deepkit/type';
+import { asyncOperation, isArray } from '@deepkit/core';
 export class HttpResponse extends ServerResponse {
     status(code) {
         this.writeHead(code);
         this.end();
     }
 }
+HttpResponse.__type = [() => ServerResponse, 'code', 'status', 'HttpResponse', 'P7!P\'2""0#5w$'];
+/**
+ * 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) {
+    return asyncOperation(__assignType((resolve, reject) => {
+        const chunks = [];
+        request.on('data', __assignType((chunk) => {
+            chunks.push(chunk);
+        }, ['chunk', '', 'P!2!"/"']));
+        request.on('end', () => {
+            const body = Buffer.concat(chunks);
+            //the router uses this now instead of trying to read the body again
+            request.body = body;
+            resolve(body);
+        });
+        request.on('error', __assignType((error) => {
+            reject(error);
+        }, [() => __ΩError, 'error', '', 'Pn!2""/#']));
+    }, ['resolve', 'reject', '', 'P"2!"2""/#']));
+}
+readBody.__type = ['request', 'readBody', 'P!2!!`/"'];
+export function createRequestWithCachedBody(request, body) {
+    var _a;
+    const headers = request.headers;
+    const method = request.method;
+    const url = request.url;
+    const writable = new Writable({
+        write: __assignType(function write(chunk, encoding, callback) {
+            callback();
+        }, ['chunk', 'encoding', 'callback', 'write', 'P"2!"2""2#"/$']),
+        writev: __assignType(function writev(chunks, callback) {
+            callback();
+        }, ['chunks', 'callback', 'writev', 'P"2!"2""/#'])
+    });
+    return new (_a = class extends HttpRequest {
+            constructor() {
+                super(...arguments);
+                this.url = url;
+                this.method = method;
+                this.position = 0;
+                this.headers = headers;
+            }
+            _read(size) {
+                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);
+                }
+            }
+        },
+        _a.__type = [() => HttpRequest, 'url', function () { return url; }, 'method', function () { return method; }, 'position', function () { return 0; }, 'headers', function () { return headers; }, 'size', '_read', 'P7!!3">#!3$>%\'3&>\'!3(>)P\'2*"0+5'],
+        _a)(writable);
+}
+createRequestWithCachedBody.__type = [() => __ΩPartial, 'request', 'body', () => HttpRequest, 'createRequestWithCachedBody', 'P!o!"2"!2#P7$/%'];
+const __ΩHttpRequestQuery = ['HttpRequestQuery', 'P&&LMw!y'];
+export { __ΩHttpRequestQuery as __ΩHttpRequestQuery };
+const __ΩHttpRequestResolvedParameters = ['HttpRequestResolvedParameters', 'P&"LMw!y'];
+export { __ΩHttpRequestResolvedParameters as __ΩHttpRequestResolvedParameters };
+const __ΩHttpRequestPositionedParameters = ['arguments', () => __ΩHttpRequestResolvedParameters, 'parameters', 'HttpRequestPositionedParameters', 'P"F4!n"4#Mw$y'];
+export { __ΩHttpRequestPositionedParameters as __ΩHttpRequestPositionedParameters };
+export class BodyValidationError {
+    constructor(errors = []) {
+        this.errors = errors;
+    }
+    hasErrors(prefix) {
+        return this.getErrors(prefix).length > 0;
+    }
+    getErrors(prefix) {
+        if (prefix)
+            return this.errors.filter(__assignType(v => v.path.startsWith(prefix), ['v', '', 'P"2!"/"']));
+        return this.errors;
+    }
+    getErrorsForPath(path) {
+        return this.errors.filter(__assignType(v => v.path === path, ['v', '', 'P"2!"/"']));
+    }
+    getErrorMessageForPath(path) {
+        return this.getErrorsForPath(path).map(__assignType(v => v.toString(), ['v', '', 'P"2!"/"'])).join(', ');
+    }
+}
+BodyValidationError.__type = [() => ValidationErrorItem, 'errors', () => [], 'constructor', 'prefix', 'hasErrors', () => ValidationErrorItem, 'getErrors', 'path', () => ValidationErrorItem, 'getErrorsForPath', 'getErrorMessageForPath', 'BodyValidationError', 'PP7!F2":9>#"0$P&2%8)0&P&2%8P7\'F0(P&2)P7*F0+P&2)&0,5w-'];
+export class ValidatedBody {
+    constructor(error, value) {
+        this.error = error;
+        this.value = value;
+    }
+    valid() {
+        return this.value !== undefined;
+    }
+}
+ValidatedBody.__type = ['T', () => BodyValidationError, 'error', 'value', 'constructor', 'valid', 'ValidatedBody', 'b!PP7"2#:e"!2$8:"0%P!0&5w\''];
+const __ΩHttpBody = ['T', () => __ΩTypeAnnotation, "httpBody", 'HttpBody', 'b!Pe"!.#o""Kw$y'];
+export { __ΩHttpBody as __ΩHttpBody };
+const __ΩHttpBodyValidation = ['T', () => ValidatedBody, () => __ΩTypeAnnotation, "httpBodyValidation", 'HttpBodyValidation', 'b!PPe#!7".$o#"Kw%y'];
+export { __ΩHttpBodyValidation as __ΩHttpBodyValidation };
+const __ΩHttpRequestParserOptions = ['withPath', 'withBody', 'withQuery', 'withHeader', 'HttpRequestParserOptions', 'P)4!8)4"8)4#8)4$8Mw%y'];
+export { __ΩHttpRequestParserOptions as __ΩHttpRequestParserOptions };
+const __ΩHttpRequestParser = ['T', () => __ΩHttpRequestParserOptions, 'options', '', () => __ΩTypeAnnotation, "httpRequestParser", 'HttpRequestParser', 'b!PPn"2#8e#!`/$.&e"!o%#Kw\'y'];
+export { __ΩHttpRequestParser as __ΩHttpRequestParser };
+const __ΩHttpPath = ['T', 'Options', () => __ΩTypeAnnotation, "httpPath", 'HttpPath', 'b!PMc"Pe"!.$e""o##Kw%y'];
+export { __ΩHttpPath as __ΩHttpPath };
+const __ΩHttpHeader = ['T', 'Options', () => __ΩTypeAnnotation, "httpHeader", 'HttpHeader', 'b!PMc"Pe"!.$e""o##Kw%y'];
+export { __ΩHttpHeader as __ΩHttpHeader };
+const __ΩHttpQuery = ['T', 'Options', () => __ΩTypeAnnotation, "httpQuery", 'HttpQuery', 'b!PMc"Pe"!.$e""o##Kw%y'];
+export { __ΩHttpQuery as __ΩHttpQuery };
+const __ΩHttpQueries = ['T', 'Options', () => __ΩTypeAnnotation, "httpQueries", 'HttpQueries', 'b!PMc"Pe"!.$e""o##Kw%y'];
+export { __ΩHttpQueries as __ΩHttpQueries };
+const __ΩHttpRegExp = ['T', 'Pattern', () => __ΩTypeAnnotation, "httpRegExp", 'HttpRegExp', 'b!b"Pe"!.$e""o##Kw%y'];
+export { __ΩHttpRegExp as __ΩHttpRegExp };
+export function getRegExp(type) {
+    const options = typeAnnotation.getType(type, 'httpRegExp');
+    if (!options)
+        return;
+    if (options.kind === ReflectionKind.literal && 'string' === typeof options.literal)
+        return options.literal;
+    if (options.kind === ReflectionKind.literal && options.literal instanceof RegExp)
+        return options.literal;
+    return;
+}
+getRegExp.__type = ['Type', 'type', 'getRegExp', 'P"w!2"P&A-J/#'];
+export class RequestBuilder {
+    constructor(path, method = 'GET') {
+        this.path = path;
+        this.method = method;
+        this.contentBuffer = Buffer.alloc(0);
+        this._headers = {};
+    }
+    getUrl() {
+        if (this.queryPath) {
+            return this.path + '?' + this.queryPath;
+        }
+        return this.path;
+    }
+    build() {
+        return createRequestWithCachedBody({
+            method: this.method,
+            url: this.getUrl(),
+            headers: this._headers,
+        }, this.contentBuffer);
+    }
+    headers(headers) {
+        this._headers = headers;
+        return this;
+    }
+    header(name, value) {
+        this._headers[name] = String(value);
+        return this;
+    }
+    json(body) {
+        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) {
+        const boundary = '--------------------------' + Math.random().toString(36).substr(2, 10);
+        this._headers['content-type'] = 'multipart/form-data; boundary=' + boundary;
+        const parts = items.map(__assignType(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');
+            }
+        }, ['item', '', 'P"2!"/"']));
+        parts.push(Buffer.from(`--${boundary}--`, 'utf8'));
+        this.contentBuffer = Buffer.concat(parts);
+        this._headers['content-length'] = String(this.contentBuffer.byteLength);
+        return this;
+    }
+    body(body) {
+        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) {
+        if ('string' === typeof query) {
+            this.queryPath = query;
+        }
+        else {
+            this.queryPath = querystring.stringify(query);
+        }
+        return this;
+    }
+}
+RequestBuilder.__type = ['contentBuffer', function () { return Buffer.alloc(0); }, '_headers', function () { return {}; }, 'queryPath', 'path', 'method', () => "GET", 'constructor', 'getUrl', () => HttpRequest, 'build', 'headers', 'name', 'value', 'header', 'body', 'json', 'file', 'fileName', 'items', 'multiPart', 'query', 'RequestBuilder', '!3!<>"P&&LM3#<>$&3%8<P&2&<&2\'<>("0)P"0*PP7+0,PP&&LM2-!0-P&2.P&\'J2/!00P%21!02PP&4.W438&448"428MF25!06PP&!J21!01PP"&J27!075w8'];
 export class HttpRequest extends IncomingMessage {
     constructor() {
         super(...arguments);
@@ -21,6 +244,40 @@ export class HttpRequest extends IncomingMessage {
          * A store that can be used to transport data from guards/listeners to ParameterResolvers/controllers.
          */
         this.store = {};
+        this.uploadedFiles = {};
+        this.throwErrorOnNotFound = false;
+    }
+    async readBody() {
+        if (this.body)
+            return this.body;
+        return await readBody(this);
+    }
+    async readBodyText() {
+        return (await this.readBody()).toString('utf8');
+    }
+    static GET(path) {
+        return new RequestBuilder(path);
+    }
+    static POST(path) {
+        return new RequestBuilder(path, 'POST');
+    }
+    static OPTIONS(path) {
+        return new RequestBuilder(path, 'OPTIONS');
+    }
+    static TRACE(path) {
+        return new RequestBuilder(path, 'TRACE');
+    }
+    static HEAD(path) {
+        return new RequestBuilder(path, 'HEAD');
+    }
+    static PATCH(path) {
+        return new RequestBuilder(path, 'PATCH');
+    }
+    static PUT(path) {
+        return new RequestBuilder(path, 'PUT');
+    }
+    static DELETE(path) {
+        return new RequestBuilder(path, 'DELETE');
     }
     getUrl() {
         return this.url || '/';
@@ -29,7 +286,106 @@ export class HttpRequest extends IncomingMessage {
         return this.method || 'GET';
     }
     getRemoteAddress() {
-        return this.connection.remoteAddress || '';
+        return this.socket.remoteAddress || '';
+    }
+}
+HttpRequest.__type = [() => IncomingMessage, 'store', function () { return {}; }, () => UploadedFile, 'uploadedFiles', function () { return {}; }, 'throwErrorOnNotFound', function () { return false; }, 'body', 'readBody', 'readBodyText', 'path', () => RequestBuilder, 'GET', () => RequestBuilder, 'POST', () => RequestBuilder, 'OPTIONS', () => RequestBuilder, 'TRACE', () => RequestBuilder, 'HEAD', () => RequestBuilder, 'PATCH', () => RequestBuilder, 'PUT', () => RequestBuilder, 'DELETE', 'getUrl', 'getMethod', 'getRemoteAddress', 'HttpRequest', 'P7!P&"LM3">#P&P7$LM3%>&)3\'>(!3)8P!`0*P&`0+P&2,P7-0.sP&2,P7/00sP&2,P7102sP&2,P7304sP&2,P7506sP&2,P7708sP&2,P790:sP&2,P7;0<sP&0=P&0>P&0?5w@'];
+export function incomingMessageToHttpRequest(request) {
+    if (request instanceof HttpRequest)
+        return request;
+    Object.setPrototypeOf(request, HttpRequest.prototype);
+    HttpRequest.constructor.call(request);
+    return request;
+}
+incomingMessageToHttpRequest.__type = ['request', () => HttpRequest, 'incomingMessageToHttpRequest', 'P!2!P7"/#'];
+export function serverResponseToHttpResponse(response) {
+    if (response instanceof HttpResponse)
+        return response;
+    Object.setPrototypeOf(response, HttpResponse.prototype);
+    MemoryHttpResponse.constructor.call(response);
+    return response;
+}
+serverResponseToHttpResponse.__type = ['response', () => HttpResponse, 'serverResponseToHttpResponse', 'P!2!P7"/#'];
+export class MemoryHttpResponse extends HttpResponse {
+    constructor() {
+        super(...arguments);
+        this.body = Buffer.alloc(0);
+        this.headers = Object.create(null);
+    }
+    setHeader(name, value) {
+        this.headers[name] = value;
+        super.setHeader(name, value);
+        return this;
+    }
+    removeHeader(name) {
+        delete this.headers[name];
+        super.removeHeader(name);
+    }
+    getHeader(name) {
+        return this.headers[name];
+    }
+    getHeaders() {
+        return this.headers;
+    }
+    writeHead(statusCode, headersOrReasonPhrase, headers) {
+        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() {
+        const json = this.bodyString;
+        try {
+            return JSON.parse(json);
+        }
+        catch (error) {
+            throw new Error(`Could not parse JSON: ${error.message}, body: ${json}`);
+        }
+    }
+    get text() {
+        return this.bodyString;
+    }
+    get bodyString() {
+        return this.body.toString('utf8');
+    }
+    write(chunk, encoding, callback) {
+        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, encoding, callback) {
+        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;
     }
 }
+MemoryHttpResponse.__type = [() => HttpResponse, 'body', function () { return Buffer.alloc(0); }, 'headers', function () { return Object.create(null); }, 'name', () => __ΩReadonlyArray, 'value', 'setHeader', 'removeHeader', 'getHeader', 'getHeaders', 'statusCode', 'headersOrReasonPhrase', 'writeHead', 'chunk', 'encoding', 'callback', 'write', 'end', 'MemoryHttpResponse', 'P7!!3">#P&P\'&&F-JLM3$>%P&2&P\'&&o\'"J2(!0)P&2&"0*P&2&"0+P!0,P\'2-P&!!FJ2.8P!!FJ2$8!0/!!!P"20"21"228"03P"20"218"228"045w5'];
 //# sourceMappingURL=model.js.map