@tsed/common 6.88.1 → 6.89.0

package/lib/types/decorators/params/next.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Get the Next function (for express application and middleware).
+ *
+ * @decorator
+ * @operation
+ * @input
+ */
+export declare function Next(): ParameterDecorator;
+declare global {
+    namespace TsED {
+        interface NextFunction extends Function {
+        }
+    }
+}
+/**
+ * Get the Next function (for express application and middleware).
+ *
+ * @decorator
+ * @operation
+ * @input
+ */
+export declare type Next = TsED.NextFunction;

package/lib/types/decorators/params/request.d.ts

@@ -0,0 +1,46 @@
+import { Type } from "@tsed/core";
+import { ParamOptions } from "@tsed/platform-params";
+/**
+ * Request service.
+ *
+ * @decorator
+ * @operation
+ * @input
+ */
+export declare function Request(expression: string, useType: Type<any>): ParameterDecorator;
+export declare function Request(expression: string): ParameterDecorator;
+export declare function Request(useType: Type<any>): ParameterDecorator;
+export declare function Request(options: ParamOptions<any>): ParameterDecorator;
+export declare function Request(): ParameterDecorator;
+/**
+ * Request service.
+ *
+ * @alias Request
+ * @decorator
+ * @operation
+ * @input
+ */
+export declare function Req(expression: string, useType: Type<any>): ParameterDecorator;
+export declare function Req(expression: string): ParameterDecorator;
+export declare function Req(useType: Type<any>): ParameterDecorator;
+export declare function Req(options: Partial<ParamOptions>): ParameterDecorator;
+export declare function Req(): ParameterDecorator;
+/**
+ * Request service.
+ *
+ * @decorator
+ * @operation
+ * @input
+ */
+export interface Request extends TsED.Request {
+}
+/**
+ * Request service.
+ *
+ * @alias Request
+ * @decorator
+ * @operation
+ * @input
+ */
+export interface Req extends Request {
+}

package/lib/types/decorators/params/response.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Response service.
+ *
+ * @decorator
+ * @operation
+ * @input
+ * @response
+ */
+export declare function Response(): ParameterDecorator;
+/**
+ * Request service.
+ *
+ * @alias Response
+ * @decorator
+ * @operation
+ * @input
+ * @response
+ */
+export declare function Res(): ParameterDecorator;
+/**
+ * Response service.
+ *
+ * @decorator
+ * @operation
+ * @input
+ * @response
+ */
+export interface Response extends TsED.Response {
+}
+/**
+ * Response service.
+ *
+ * @alias Response
+ * @decorator
+ * @operation
+ * @input
+ * @response
+ */
+export interface Res extends Response {
+}

package/lib/types/decorators/params/responseData.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Return the current response data. Prefer the @@Context@@ decorator to get or set data.
+ *
+ * @decorator
+ * @operation
+ * @input
+ * @deprecated Use `@Context() $ctx: Context` then $ctx.data.
+ */
+export declare function ResponseData(): ParameterDecorator;

package/lib/types/domain/AnyToPromiseWithCtx.d.ts

@@ -0,0 +1,18 @@
+import { AnyPromiseResult, AnyToPromise } from "@tsed/core";
+import { PlatformContext } from "./PlatformContext";
+/**
+ * @ignore
+ */
+export interface HandlerContextOptions {
+    $ctx: PlatformContext;
+    err?: any;
+}
+export declare class AnyToPromiseWithCtx extends AnyToPromise {
+    $ctx: PlatformContext;
+    err: unknown;
+    constructor({ $ctx, err }: HandlerContextOptions);
+    isDone(): boolean;
+    call(cb: Function): Promise<AnyPromiseResult<any>>;
+    destroy(): void;
+    isCanceledResponse(process: any): boolean;
+}

package/lib/types/domain/ControllerProvider.d.ts

@@ -0,0 +1,24 @@
+import { ControllerMiddlewares, Provider, TokenProvider } from "@tsed/di";
+export declare class ControllerProvider<T = any> extends Provider<T> {
+    readonly tokenRouter: string;
+    constructor(provide: TokenProvider, options?: Partial<Provider>);
+    /**
+     *
+     */
+    get routerOptions(): any;
+    /**
+     *
+     * @param value
+     */
+    set routerOptions(value: any);
+    /**
+     *
+     * @returns {any[]}
+     */
+    get middlewares(): ControllerMiddlewares;
+    /**
+     *
+     * @param middlewares
+     */
+    set middlewares(middlewares: ControllerMiddlewares);
+}

package/lib/types/domain/EndpointMetadata.d.ts

@@ -0,0 +1,76 @@
+import { Type } from "@tsed/core";
+import { ParamMetadata } from "@tsed/platform-params";
+import { JsonEntityStoreOptions, JsonMethodStore, JsonOperation } from "@tsed/schema";
+export interface EndpointConstructorOptions extends JsonEntityStoreOptions {
+    beforeMiddlewares?: Function[];
+    middlewares?: Function[];
+    afterMiddlewares?: Function[];
+}
+export interface EndpointViewOptions {
+    path: string;
+    options: any;
+}
+export interface EndpointRedirectOptions {
+    status: number | undefined;
+    url: string;
+}
+/**
+ * EndpointMetadata contains metadata about a controller and his method.
+ * Each annotation (@Get, @Body...) attached to a method are stored in a endpoint.
+ * EndpointMetadata convert this metadata to an array which contain arguments to call an Express method.
+ *
+ * Example :
+ *
+ *    @Controller("/my-path")
+ *    provide MyClass {
+ *
+ *        @Get("/")
+ *        @Authenticated()
+ *        public myMethod(){}
+ *    }
+ *
+ */
+export declare class EndpointMetadata extends JsonMethodStore implements EndpointConstructorOptions {
+    beforeMiddlewares: any[];
+    middlewares: any[];
+    afterMiddlewares: any[];
+    constructor(options: EndpointConstructorOptions);
+    get targetName(): string;
+    get params(): ParamMetadata[];
+    get view(): EndpointViewOptions;
+    set view(view: EndpointViewOptions);
+    get acceptMimes(): string[];
+    set acceptMimes(mimes: string[]);
+    /**
+     * Get an endpoint.
+     * @param target
+     * @param propertyKey
+     * @param descriptor
+     */
+    static get(target: Type<any>, propertyKey: string | symbol, descriptor?: PropertyDescriptor): EndpointMetadata;
+    addOperationPath(method: string, path: string | RegExp, options?: any): JsonOperation;
+    /**
+     * Find the a value at the controller level. Let this value be extended or overridden by the endpoint itself.
+     *
+     * @param key
+     * @returns {any}
+     */
+    get<T = any>(key: any): T;
+    /**
+     * Append middlewares to the beforeMiddlewares list.
+     * @param args
+     * @returns {EndpointMetadata}
+     */
+    before(args: Function[]): this;
+    /**
+     * Append middlewares to the afterMiddlewares list.
+     * @param args
+     * @returns {EndpointMetadata}
+     */
+    after(args: Function[]): this;
+    /**
+     * Store all arguments collected via Annotation.
+     * @param args
+     */
+    use(args: Function[]): this;
+}

package/lib/types/domain/HandlerMetadata.d.ts

@@ -0,0 +1,32 @@
+import { Type } from "@tsed/core";
+import { ProviderScope } from "@tsed/di";
+import { JsonParameterStore } from "@tsed/schema";
+import { HandlerType } from "../interfaces/HandlerType";
+import { PlatformRouteOptions, PlatformRouteWithoutHandlers } from "../interfaces/PlatformRouteOptions";
+export interface HandlerMetadataOptions {
+    target: (Type<any> | Function) & {
+        type?: HandlerType;
+    };
+    routeOptions?: PlatformRouteWithoutHandlers;
+    token?: Type<any>;
+    propertyKey?: string | symbol;
+    scope?: ProviderScope;
+    type?: HandlerType;
+}
+export declare class HandlerMetadata {
+    readonly target: any;
+    readonly token: Type<any>;
+    readonly propertyKey: string | symbol;
+    readonly injectable: boolean;
+    readonly type: HandlerType;
+    readonly hasNextFunction: boolean;
+    readonly routeOptions: Partial<PlatformRouteOptions>;
+    readonly scope: ProviderScope;
+    handler: any;
+    constructor(options: HandlerMetadataOptions);
+    get hasErrorParam(): boolean;
+    getParams(): JsonParameterStore[];
+    hasParamType(paramType: any): boolean;
+    isFinal(): boolean;
+    toString(): string;
+}

package/lib/types/domain/PlatformContext.d.ts

@@ -0,0 +1,65 @@
+/// <reference types="node" />
+import { ContextMethods, DIContext, DIContextOptions } from "@tsed/di";
+import { IncomingMessage, ServerResponse } from "http";
+import { EndpointMetadata } from "./EndpointMetadata";
+import { PlatformApplication } from "../services/PlatformApplication";
+import { PlatformRequest } from "../services/PlatformRequest";
+import { PlatformResponse } from "../services/PlatformResponse";
+declare global {
+    namespace TsED {
+        interface Context extends PlatformContext {
+        }
+    }
+}
+export interface PlatformContextOptions extends DIContextOptions {
+    event: {
+        response?: ServerResponse;
+        request?: IncomingMessage;
+    };
+    ignoreUrlPatterns?: any[];
+    endpoint?: EndpointMetadata;
+}
+export declare class PlatformContext extends DIContext implements ContextMethods {
+    /**
+     * The current @@EndpointMetadata@@ resolved by Ts.ED during the request.
+     */
+    endpoint: EndpointMetadata;
+    /**
+     * The data return by the previous endpoint if you use multiple handler on the same route. By default data is empty.
+     */
+    data: any;
+    /**
+     * The current @@PlatformResponse@@.
+     */
+    response: PlatformResponse;
+    /**
+     * The current @@PlatformRequest@@.
+     */
+    request: PlatformRequest;
+    private ignoreUrlPatterns;
+    constructor({ event, endpoint, ignoreUrlPatterns, ResponseKlass, RequestKlass, ...options }: PlatformContextOptions);
+    get url(): string;
+    get app(): PlatformApplication<TsED.Application, TsED.Router>;
+    destroy(): Promise<void>;
+    isDone(): boolean;
+    /**
+     * Return the framework request instance (Express, Koa, etc...)
+     */
+    getRequest<Req = any>(): Req;
+    /**
+     * Return the framework response instance (Express, Koa, etc...)
+     */
+    getResponse<Res = any>(): Res;
+    /**
+     * Get Node.js request
+     */
+    getReq(): IncomingMessage;
+    /**
+     * Get Node.js response
+     */
+    getRes(): ServerResponse;
+    /**
+     * Return the original application instance.
+     */
+    getApp<T = any>(): T;
+}

package/lib/types/domain/PlatformRouteDetails.d.ts

@@ -0,0 +1,23 @@
+import { JsonOperationRoute } from "@tsed/schema";
+import { EndpointMetadata } from "./EndpointMetadata";
+import { ControllerProvider } from "./ControllerProvider";
+export interface PlatformRouterDetailsOptions {
+    provider: ControllerProvider;
+    endpoint: EndpointMetadata;
+    method: string;
+    url: string;
+}
+export declare class PlatformRouteDetails extends JsonOperationRoute<EndpointMetadata> {
+    readonly rawBody: boolean;
+    readonly provider: ControllerProvider;
+    constructor(options?: Partial<PlatformRouteDetails>);
+    toJSON(): {
+        method: string;
+        name: string;
+        url: string;
+        className: string;
+        methodClassName: string;
+        parameters: any;
+        rawBody: boolean;
+    };
+}

package/lib/types/domain/PropertyMetadata.d.ts

@@ -0,0 +1,17 @@
+import { Type } from "@tsed/core";
+import { JsonPropertyStore } from "@tsed/schema";
+/**
+ * @deprecated Since 2020-11-11. Use getProperties from @tsed/schema
+ */
+export declare class PropertyMetadata extends JsonPropertyStore {
+    /**
+     * @deprecated Since 2020-11-11. Use getProperties from @tsed/schema
+     */
+    static get(target: Type<any>, propertyKey: string | symbol): PropertyMetadata;
+    /**
+     * @deprecated Since 2020-11-11. Use getProperties from @tsed/schema
+     */
+    static getProperties(target: Type<any>, options?: Partial<{
+        withIgnoredProps: boolean;
+    }>): Map<string | number | symbol, JsonPropertyStore>;
+}

package/lib/types/domain/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./AnyToPromiseWithCtx";
+export * from "./PlatformContext";
+export * from "./PlatformRouteDetails";
+export * from "./ControllerProvider";
+export * from "./EndpointMetadata";
+export * from "./HandlerMetadata";
+export * from "./PropertyMetadata";

package/lib/types/index.d.ts

@@ -0,0 +1,22 @@
+import "@tsed/logger";
+import "@tsed/logger-file";
+export * from "@tsed/di";
+export * from "@tsed/platform-params";
+export * from "@tsed/platform-exceptions";
+export * from "@tsed/platform-response-filter";
+export * from "@tsed/platform-cache";
+export * from "@tsed/platform-middlewares";
+export * from "@tsed/components-scan";
+export * from "@tsed/platform-log-middleware";
+export { $log, Logger } from "@tsed/logger";
+export * from "./config";
+export * from "./builder/PlatformBuilder";
+export * from "./builder/PlatformControllerBuilder";
+export * from "./decorators";
+export * from "./constants/routerOptions";
+export * from "./interfaces";
+export * from "./middlewares";
+export * from "./domain";
+export * from "./services";
+export * from "./utils";
+export * from "./PlatformModule";

package/lib/types/interfaces/AfterInit.d.ts

@@ -0,0 +1,3 @@
+export interface AfterInit {
+    $afterInit(): void | Promise<any>;
+}

package/lib/types/interfaces/AfterListen.d.ts

@@ -0,0 +1,3 @@
+export interface AfterListen {
+    $afterListen(): void | Promise<any>;
+}

package/lib/types/interfaces/AfterRoutesInit.d.ts

@@ -0,0 +1,3 @@
+export interface AfterRoutesInit {
+    $afterRoutesInit(): void | Promise<any>;
+}

package/lib/types/interfaces/BeforeInit.d.ts

@@ -0,0 +1,3 @@
+export interface BeforeInit {
+    $beforeInit(): void | Promise<any>;
+}

package/lib/types/interfaces/BeforeListen.d.ts

@@ -0,0 +1,3 @@
+export interface BeforeListen {
+    $beforeListen(): void | Promise<any>;
+}

package/lib/types/interfaces/BeforeRoutesInit.d.ts

@@ -0,0 +1,3 @@
+export interface BeforeRoutesInit {
+    $beforeRoutesInit(): void | Promise<any>;
+}

package/lib/types/interfaces/HandlerType.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @ignore
+ */
+export declare enum HandlerType {
+    CUSTOM = "custom",
+    ENDPOINT = "endpoint",
+    MIDDLEWARE = "middleware",
+    ERR_MIDDLEWARE = "err:middleware",
+    CTX_FN = "context",
+    RAW_FN = "raw:middleware",
+    RAW_ERR_FN = "raw:err:middleware"
+}

package/lib/types/interfaces/IncomingEvent.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+import { IncomingMessage, ServerResponse } from "http";
+export interface IncomingEvent<Req = IncomingMessage, Res = ServerResponse> extends Record<string, unknown> {
+    response: Res;
+    request: Req;
+}

package/lib/types/interfaces/OnReady.d.ts

@@ -0,0 +1,3 @@
+export interface OnReady {
+    $onReady(): void | Promise<any>;
+}

package/lib/types/interfaces/OnRequest.d.ts

@@ -0,0 +1,4 @@
+import { PlatformContext } from "../domain/PlatformContext";
+export interface OnRequest {
+    $onRequest(ctx: PlatformContext): void;
+}

package/lib/types/interfaces/OnResponse.d.ts

@@ -0,0 +1,4 @@
+import { PlatformResponse } from "../services/PlatformResponse";
+export interface OnResponse {
+    $onResponse(ctx: PlatformResponse): void;
+}

package/lib/types/interfaces/OnRoutesInit.d.ts

@@ -0,0 +1,3 @@
+export interface OnRoutesInit {
+    $onRoutesInit(): void | Promise<any>;
+}

package/lib/types/interfaces/PathType.d.ts

@@ -0,0 +1 @@
+export declare type PathType = string | RegExp | (string | RegExp)[];

package/lib/types/interfaces/PlatformRouteOptions.d.ts

@@ -0,0 +1,16 @@
+import { Type } from "@tsed/core";
+import { PathType } from "./PathType";
+/**
+ * @ignore
+ */
+export interface PlatformRouteOptions {
+    token?: Type<any>;
+    path?: PathType | undefined;
+    method?: string;
+    isFinal?: boolean;
+    handlers: any[];
+}
+/**
+ * @ignore
+ */
+export declare type PlatformRouteWithoutHandlers = Partial<Omit<PlatformRouteOptions, "handlers">>;

package/lib/types/interfaces/ResponseErrorObject.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Interface can be implemented to customize the error sent to the client.
+ */
+export interface ResponseErrorObject extends Error {
+    errors?: Error[] | Error | any;
+    origin?: Error;
+    headers?: {};
+}

package/lib/types/interfaces/Route.d.ts

@@ -0,0 +1,10 @@
+import { TokenProvider } from "@tsed/di";
+import { ControllerProvider } from "../domain/ControllerProvider";
+export interface Route extends Record<string, any> {
+    route: string;
+    token: TokenProvider;
+}
+export interface RouteController {
+    route: string;
+    provider: ControllerProvider;
+}

package/lib/types/interfaces/index.d.ts

@@ -0,0 +1,16 @@
+export * from "./ResponseErrorObject";
+export * from "./HandlerType";
+export * from "./PlatformRouteOptions";
+export * from "./BeforeInit";
+export * from "./AfterInit";
+export * from "./AfterRoutesInit";
+export * from "./BeforeListen";
+export * from "./AfterListen";
+export * from "./BeforeRoutesInit";
+export * from "./AfterRoutesInit";
+export * from "./OnRoutesInit";
+export * from "./OnReady";
+export * from "./OnRequest";
+export * from "./OnResponse";
+export * from "./Route";
+export * from "./IncomingEvent";

package/lib/types/middlewares/AcceptMimesMiddleware.d.ts

@@ -0,0 +1,10 @@
+import { Context } from "@tsed/platform-params";
+import { MiddlewareMethods } from "@tsed/platform-middlewares";
+/**
+ * @middleware
+ * @deprecated Since 2020-11-30. Use PlatformAcceptMimesMiddleware.
+ * @ignore
+ */
+export declare class AcceptMimesMiddleware implements MiddlewareMethods {
+    use(ctx: Context): void;
+}

package/lib/types/middlewares/GlobalAcceptMimesMiddleware.d.ts

@@ -0,0 +1,9 @@
+import { MiddlewareMethods } from "@tsed/platform-middlewares";
+import { Context } from "@tsed/platform-params";
+/**
+ * @deprecated Since 2020-11-30. Use PlatformAcceptMimesMiddleware.
+ * @ignore
+ */
+export declare class GlobalAcceptMimesMiddleware implements MiddlewareMethods {
+    use(ctx: Context): void;
+}

package/lib/types/middlewares/PlatformAcceptMimesMiddleware.d.ts

@@ -0,0 +1,10 @@
+import { MiddlewareMethods } from "@tsed/platform-middlewares";
+import { Context } from "@tsed/platform-params";
+/**
+ * @middleware
+ * @platform
+ */
+export declare class PlatformAcceptMimesMiddleware implements MiddlewareMethods {
+    acceptMimes: string[];
+    use(ctx: Context): void;
+}

package/lib/types/middlewares/PlatformMulterMiddleware.d.ts

@@ -0,0 +1,19 @@
+import { MiddlewareMethods } from "@tsed/platform-middlewares";
+import { Context } from "@tsed/platform-params";
+import { PlatformMulterField, PlatformMulterSettings } from "../config";
+import { PlatformApplication } from "../services/PlatformApplication";
+export interface MulterInputOptions {
+    fields: PlatformMulterField[];
+}
+/**
+ * @middleware
+ */
+export declare class PlatformMulterMiddleware implements MiddlewareMethods {
+    settings: PlatformMulterSettings;
+    app: PlatformApplication;
+    use(ctx: Context): Promise<any>;
+    protected getFields(conf: MulterInputOptions): {
+        name: string;
+        maxCount: number | undefined;
+    }[];
+}

package/lib/types/middlewares/__mock__/FakeCtrl.d.ts

@@ -0,0 +1,2 @@
+export declare class FakeCtrl {
+}

package/lib/types/middlewares/bindEndpointMiddleware.d.ts

@@ -0,0 +1,5 @@
+import type { EndpointMetadata, PlatformContext } from "../domain";
+/**
+ * @ignore
+ */
+export declare function bindEndpointMiddleware(endpoint: EndpointMetadata): (ctx: PlatformContext) => void;

package/lib/types/middlewares/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./bindEndpointMiddleware";
+export * from "./PlatformMulterMiddleware";
+export * from "./GlobalAcceptMimesMiddleware";
+export * from "./PlatformAcceptMimesMiddleware";
+export * from "./AcceptMimesMiddleware";

package/lib/types/services/FakeRawDriver.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @ignore
+ */
+export declare const createFakeRawDriver: () => {
+    (): void;
+    use: () => any;
+    all: () => any;
+    get: () => any;
+    patch: () => any;
+    post: () => any;
+    put: () => any;
+    head: () => any;
+    delete: () => any;
+    options: () => any;
+};