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

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

@@ -0,0 +1 @@
+{"version":3,"file":"middleware.js","sourceRoot":"","sources":["../../../src/middleware.ts"],"names":[],"mappings":";;;;iCAAmC,eAAe;AAAlD,wCAAmD;AACnD,sCAAyC;AACzC,wCAA2D;AAC3D,yCAAuD;AACvD,gDAAmD;;;;;;;AAkBnD,MAAa,oBAAoB;IAAjC;QAEI,gBAAW,GAAqD,EAAE,CAAC;QAEnE,WAAM,GAA0B,EAAE,CAAC;QACnC,kBAAa,GAA0B,EAAE,CAAC;QAE1C,UAAK,GAAW,CAAC,CAAC;QAElB,gBAAW,GAAgB,EAAE,CAAC;QAC9B,uBAAkB,GAAgB,EAAE,CAAC;QAErC,eAAU,GAAa,EAAE,CAAC;QAC1B,sBAAiB,GAAa,EAAE,CAAC;QAIjC,YAAO,GAA0B,EAAE,CAAC;QAEpC,eAAU,GAAY,KAAK,CAAC;KAU/B;IARG,aAAa;QACT,MAAM,UAAU,GAAgB,EAAE,CAAC;QACnC,KAAK,MAAM,UAAU,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC;YACxC,IAAI,IAAA,cAAO,EAAC,UAAU,CAAC;gBAAE,UAAU,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QACzD,CAAC;QAED,OAAO,UAAU,CAAC;IACtB,CAAC;;AA5BL,oDA6BC;mJA3BmE,EAAE,kEAElC,EAAE,yEACK,EAAE,mCAEzB,CAAC,6DAEU,EAAE,oEACK,EAAE,wCAEb,EAAE,+CACK,EAAE,iFAIC,EAAE,wCAEb,KAAK;AAY/B,MAAa,iBAAiB;IAA9B;QACI,MAAC,GAAG,IAAI,oBAAoB,CAAC;KA2DhC;IAzDG,IAAI,CAAC,IAAY;QACb,IAAI,CAAC,CAAC,CAAC,IAAI,GAAG,IAAI,CAAC;IACvB,CAAC;IAED,GAAG,CAAC,GAAG,WAA6D;QAChE,IAAI,CAAC,CAAC,CAAC,WAAW,GAAG,WAAW,CAAC;IACrC,CAAC;IAED,SAAS,CAAC,GAAG,MAA6B;QACtC,IAAI,CAAC,CAAC,CAAC,MAAM,GAAG,MAAM,CAAC;IAC3B,CAAC;IAED,aAAa,CAAC,GAAG,MAA6B;QAC1C,IAAI,CAAC,CAAC,CAAC,aAAa,GAAG,MAAM,CAAC;IAClC,CAAC;IAED,aAAa,CAAC,GAAG,KAAe;QAC5B,IAAI,CAAC,CAAC,CAAC,UAAU,GAAG,KAAK,CAAC;IAC9B,CAAC;IAED,iBAAiB,CAAC,GAAG,KAAe;QAChC,IAAI,CAAC,CAAC,CAAC,iBAAiB,GAAG,KAAK,CAAC;IACrC,CAAC;IAED;;;OAGG;IACH,OAAO,CAAC,OAAe;QACnB,IAAI,CAAC,CAAC,CAAC,OAAO,GAAG,OAAO,CAAC;IAC7B,CAAC;IAED,cAAc,CAAC,GAAG,WAAwB;QACtC,IAAI,CAAC,CAAC,CAAC,WAAW,GAAG,WAAW,CAAC;IACrC,CAAC;IAED,kBAAkB,CAAC,GAAG,WAAwB;QAC1C,IAAI,CAAC,CAAC,CAAC,kBAAkB,GAAG,WAAW,CAAC;IAC5C,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,KAAa;QACf,IAAI,CAAC,CAAC,CAAC,KAAK,GAAG,KAAK,CAAC;IACzB,CAAC;IAED,UAAU,CAAC,GAAG,OAAyB;QACnC,IAAI,CAAC,CAAC,CAAC,OAAO,GAAG,OAAO,CAAC;IAC7B,CAAC;IAED;;OAEG;IACH,cAAc;QACV,IAAI,CAAC,CAAC,CAAC,UAAU,GAAG,IAAI,CAAC;IAC7B,CAAC;;AA3DL,8CA4DC;sDA3DO,IAAI,oBAAoB;AA6DnB,QAAA,cAAc,GAAG,IAAA,iCAA0B,EAAC,iBAAiB,CAAC,CAAC"}

package/dist/cjs/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[];