@tsed/common 7.0.0-alpha.2 → 7.0.0-beta.1

package/lib/esm/utils/useCtxHandler.js

@@ -0,0 +1,11 @@
+import { HandlerType } from "../interfaces/HandlerType";
+/**
+ * Create Ts.ED context handler
+ * @param fn
+ * @ignore
+ */
+export function useCtxHandler(fn) {
+    fn.type = HandlerType.CTX_FN;
+    return fn;
+}
+//# sourceMappingURL=useCtxHandler.js.map

package/lib/esm/utils/useCtxHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCtxHandler.js","sourceRoot":"","sources":["../../../src/utils/useCtxHandler.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,WAAW,EAAC,MAAM,2BAA2B,CAAC;AAItD;;;;GAIG;AACH,MAAM,UAAU,aAAa,CAAC,EAA6C;IACzE,EAAE,CAAC,IAAI,GAAG,WAAW,CAAC,MAAM,CAAC;IAE7B,OAAO,EAAE,CAAC;AACZ,CAAC","sourcesContent":["import {PlatformContext} from \"../domain/PlatformContext\";\nimport {HandlerType} from \"../interfaces/HandlerType\";\n\nexport type PlatformCtxHandler = ($ctx: PlatformContext) => any | Promise<any>;\n\n/**\n * Create Ts.ED context handler\n * @param fn\n * @ignore\n */\nexport function useCtxHandler(fn: PlatformCtxHandler & {type?: HandlerType}) {\n  fn.type = HandlerType.CTX_FN;\n\n  return fn;\n}\n"]}

package/lib/{builder → types/builder}/PlatformBuilder.d.ts

@@ -1,32 +1,20 @@
+/// <reference types="node" />
 import { Type } from "@tsed/core";
-import { Container, InjectorService, IProvider } from "@tsed/di";
+import { InjectorService, IProvider } from "@tsed/di";
 import { Platform } from "../services/Platform";
 import { PlatformApplication } from "../services/PlatformApplication";
-/**
- * @ignore
- */
-export interface PlatformType<T = any> extends Type<T> {
-    providers: IProvider[];
-}
-/**
- * @ignore
- */
-export interface PlatformBootstrap {
-    bootstrap(module: Type<any>, settings?: Partial<TsED.Configuration>): Promise<PlatformBuilder>;
-}
+import { IncomingMessage, ServerResponse } from "http";
+import { PlatformAdapter, PlatformBuilderSettings } from "../interfaces/PlatformAdapter";
 /**
  * @platform
  */
-export declare abstract class PlatformBuilder<App = TsED.Application, Router = TsED.Router> {
+export declare class PlatformBuilder<App = TsED.Application, Router = TsED.Router> {
     #private;
-    static currentPlatform: Type<PlatformBuilder<any, any>> & PlatformBootstrap;
+    static adapter: Type<PlatformAdapter>;
     readonly name: string;
     protected startedAt: Date;
-    protected locals: Container;
-    constructor({ name, providers }: {
-        name: string;
-        providers: IProvider[];
-    });
+    protected current: Date;
+    protected constructor(adapter: Type<PlatformAdapter<App, Router>> | undefined, module: Type, settings: Partial<TsED.Configuration>);
     get injector(): InjectorService;
     get rootModule(): any;
     get app(): PlatformApplication<App, Router>;
@@ -55,7 +43,16 @@ export declare abstract class PlatformBuilder<App = TsED.Application, Router = T
     get settings(): TsED.Configuration & import("@tsed/di").DIConfiguration;
     get logger(): import("@tsed/di").DILogger;
     get disableBootstrapLog(): boolean | undefined;
-    static build<T extends PlatformBuilder<any, any>>(platformBuildClass: PlatformType<T>): T;
+    static create<App = TsED.Application, Router = TsED.Router>(module: Type<any>, settings: PlatformBuilderSettings<App, Router>): PlatformBuilder<App, Router>;
+    static build<App = TsED.Application, Router = TsED.Router>(module: Type<any>, { adapter, ...settings }: PlatformBuilderSettings<App, Router>): PlatformBuilder<App, Router>;
+    /**
+     * Bootstrap a server application
+     * @param module
+     * @param settings
+     */
+    static bootstrap<App = TsED.Application, Router = TsED.Router>(module: Type<any>, settings: PlatformBuilderSettings<App, Router>): Promise<PlatformBuilder<App, Router>>;
+    callback(): (req: IncomingMessage, res: ServerResponse) => void;
+    callback(req: IncomingMessage, res: ServerResponse): void;
     log(...data: any[]): any;
     /**
      * Add classes to the components list
@@ -83,14 +80,17 @@ export declare abstract class PlatformBuilder<App = TsED.Application, Router = T
      * @param {any[]} controllers
      */
     addControllers(endpoint: string, controllers: any | string | (any | string)[]): void;
-    runLifecycle(): Promise<void>;
+    runLifecycle(): Promise<this>;
     loadInjector(): Promise<void>;
-    listen(): Promise<void>;
+    listen(network?: boolean): Promise<void>;
     stop(): Promise<void>;
     ready(): Promise<void>;
     callHook(hook: string, ...args: any[]): Promise<void>;
-    loadStatics(): Promise<void>;
+    loadStatics(hook: string): Promise<void>;
     useProvider(token: Type<any>, settings?: Partial<IProvider>): this;
+    bootstrap(): Promise<this>;
+    protected loadRoutes(): Promise<void>;
+    protected diff(): string;
     protected importProviders(): Promise<void>;
     /**
      * Load middlewares from configuration for the given hook
@@ -98,12 +98,7 @@ export declare abstract class PlatformBuilder<App = TsED.Application, Router = T
      * @protected
      */
     protected loadMiddlewaresFor(hook: string): void;
-    protected useRouter(): this;
-    protected useContext(): this;
-    protected bootstrap(module: Type<any>, settings?: Partial<TsED.Configuration>): Promise<this>;
+    protected createHttpServers(): void;
     protected listenServers(): Promise<void>;
     protected logRoutes(): Promise<void>;
-    protected loadRoutes(): Promise<void>;
-    protected createInjector(module: Type<any>, settings: any): void;
-    protected createRootModule(module: Type<any>): void;
 }

package/lib/types/builder/PlatformControllerBuilder.d.ts

@@ -0,0 +1,17 @@
+import { InjectorService } from "@tsed/di";
+import { ControllerProvider } from "../domain/ControllerProvider";
+import { PlatformRouter } from "../services/PlatformRouter";
+/**
+ * @ignore
+ */
+export declare function getRouter(injector: InjectorService, provider: ControllerProvider): any;
+/**
+ * @ignore
+ */
+export declare function createRouter(injector: InjectorService, provider: ControllerProvider): PlatformRouter;
+/**
+ * @ignore
+ * @param injector
+ * @param provider
+ */
+export declare function buildRouter(injector: InjectorService, provider: ControllerProvider): PlatformRouter<TsED.Router>;

package/lib/{config → types/config}/interfaces/PlatformStaticsSettings.d.ts

@@ -2,6 +2,7 @@ declare global {
     namespace TsED {
         interface StaticsOptions {
             root: string;
+            hook?: "$beforeRoutesInit" | "$afterRoutesInit";
             [key: string]: any;
         }
     }

package/lib/{config → types/config}/interfaces/index.d.ts

@@ -1,11 +1,12 @@
 /// <reference types="node" />
 import { Env } from "@tsed/core";
-import Https from "https";
 import { ConverterSettings } from "./ConverterSettings";
 import { EndpointDirectoriesSettings } from "./EndpointDirectoriesSettings";
 import { PlatformLoggerSettings } from "./PlatformLoggerSettings";
 import { PlatformMulterSettings } from "./PlatformMulterSettings";
 import { PlatformStaticsSettings } from "./PlatformStaticsSettings";
+import type Http from "http";
+import type Https from "https";
 declare global {
     namespace TsED {
         interface LoggerConfiguration extends Partial<PlatformLoggerSettings> {
@@ -27,6 +28,14 @@ declare global {
              * Port number for the [HTTP.Server](https://nodejs.org/api/http.html#http_class_http_server).
              */
             httpPort: string | number | boolean;
+            /**
+             * [Https.ServerOptions](https://nodejs.org/api/tls.html#tls_tls_createserver_options_secureconnectionlistener)):
+             * - `key` &lt;string&gt; | &lt;string[]&gt; | [&lt;Buffer&gt;](https://nodejs.org/api/buffer.html#buffer_class_buffer) | &lt;Object[]&gt;: The private key of the server in PEM format. To support multiple keys using different algorithms an array can be provided either as a plain array of key strings or an array of objects in the format `{pem: key, passphrase: passphrase}`. This option is required for ciphers that make use of private keys.
+             * - `passphrase` &lt;string&gt; A string containing the passphrase for the private key or pfx.
+             * - `cert` &lt;string&gt; | &lt;string[]&gt; | [&lt;Buffer&gt;](https://nodejs.org/api/buffer.html#buffer_class_buffer) | [&lt;Buffer[]&gt;](https://nodejs.org/api/buffer.html#buffer_class_buffer): A string, Buffer, array of strings, or array of Buffers containing the certificate key of the server in PEM format. (Required)
+             * - `ca` &lt;string&gt; | &lt;string[]&gt; | [&lt;Buffer&gt;](https://nodejs.org/api/buffer.html#buffer_class_buffer) | [&lt;Buffer[]&gt;](https://nodejs.org/api/buffer.html#buffer_class_buffer): A string, Buffer, array of strings, or array of Buffers of trusted certificates in PEM format. If this is omitted several well known "root" CAs (like VeriSign) will be used. These are used to authorize connections.
+             */
+            httpOptions: Http.ServerOptions;
             /**
              * Port number for the [HTTPs.Server](https://nodejs.org/api/https.html#https_class_https_server).
              */
@@ -47,6 +56,10 @@ declare global {
              * List of directories to scan [Services](/docs/services.md), [Middlewares](/docs/middlewares.md) or [Converters](/docs/converters.md).
              */
             componentsScan: (string | RegExp)[];
+            /**
+             * Disable the glob pattern. In v7 the componentsScan options will be removed in favor of external module loader.
+             */
+            disableComponentsScan: boolean;
             /**
              * List of glob patterns. Exclude all files which matching with this list when Server scan all components with the `mount` or `scanComponents` options.
              */

package/lib/{config → types/config}/services/PlatformConfiguration.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { Env } from "@tsed/core";
+import { Env, getHostInfoFromPort } from "@tsed/core";
 import { DIConfiguration } from "@tsed/di";
 import Https from "https";
 import { EndpointDirectoriesSettings, PlatformLoggerSettings } from "../interfaces";
@@ -40,20 +40,11 @@ export declare class PlatformConfiguration extends DIConfiguration {
     get exclude(): string[];
     set exclude(exclude: string[]);
     get additionalProperties(): boolean;
-    /**
-     *
-     * @param addressPort
-     * @returns {{address: string, port: number}}
-     */
-    private static buildAddressAndPort;
     /**
      *
      * @returns {string|number}
      */
-    getHttpPort(): {
-        address: string;
-        port: number;
-    };
+    getHttpPort(): ReturnType<typeof getHostInfoFromPort>;
     /**
      *
      * @param settings
@@ -67,8 +58,10 @@ export declare class PlatformConfiguration extends DIConfiguration {
      * @returns {string|number}
      */
     getHttpsPort(): {
+        protocol: string;
         address: string;
         port: number;
+        toString(): string;
     };
     /**
      *
@@ -78,4 +71,12 @@ export declare class PlatformConfiguration extends DIConfiguration {
         address: string;
         port: number;
     }): void;
+    getBestHost(): {
+        protocol: string;
+        address: string;
+        port: number;
+        toString(): string;
+    } | {
+        toString(): string;
+    };
 }

package/lib/{decorators → types/decorators}/httpServer.d.ts

@@ -22,6 +22,7 @@ import Http from "http";
  * @param {TypedPropertyDescriptor<Function> | number} descriptor
  * @returns {any}
  * @decorator
+ * @deprecated Use Https.Server from "http"
  */
 export declare function HttpServer(target: Type<any>, targetKey: string, descriptor: TypedPropertyDescriptor<Function> | number): any;
 export declare type HttpServer = Http.Server;

package/lib/{decorators → types/decorators}/httpsServer.d.ts

@@ -22,6 +22,7 @@ import Https from "https";
  * @param {TypedPropertyDescriptor<Function> | number} descriptor
  * @returns {any}
  * @decorator
+ * @deprecated Use Https.Server from "https"
  */
 export declare function HttpsServer(target: Type<any>, targetKey: string, descriptor: TypedPropertyDescriptor<Function> | number): any;
 export declare type HttpsServer = Https.Server;

package/lib/{decorators → types/decorators}/index.d.ts

@@ -6,6 +6,7 @@ export * from "./method/acceptMime";
 export * from "./method/location";
 export * from "./method/redirect";
 export * from "./method/endpointFn";
+export * from "./method/view";
 export * from "./params/response";
 export * from "./params/request";
 export * from "./params/next";

package/lib/{decorators → types/decorators}/method/endpointFn.d.ts

@@ -4,5 +4,6 @@ import { EndpointMetadata } from "../../domain";
  *
  * @param fn
  * @decorator
+ * @deprecated Deprecated since 2021-10-05. Use JsonEntityFn instead.
  */
 export declare function EndpointFn(fn: (endpoint: EndpointMetadata, parameters: DecoratorParameters) => void): MethodDecorator;

package/lib/types/decorators/method/view.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Use a view and sends the rendered HTML string to the client. Optional parameter:
+ *
+ * * viewOptions, an object whose properties define local variables for the view.
+ *
+ * The view argument is a string that is the file path of the view file to render.
+ * This can be an absolute path, or a path relative to the views setting.
+ * If the path does not contain a file extension, then the view engine setting determines the file extension.
+ * If the path does contain a file extension, then Express will load the module for the specified template engine (via require())
+ * and render it using the loaded module’s __express function.
+ *
+ * For more information, see [Using template engines with Express](http://expressjs.com/guide/using-template-engines.html).
+ *
+ * > NOTE: The view argument performs file system operations like reading a file from disk and evaluating Node.js modules,
+ * and as so for security reasons should not contain input from the end-user.
+ *
+ * @param path Relative path to the view file.
+ * @param options Additional options
+ * @decorator
+ * @operation
+ * @response
+ * @ignores
+ * @deprecated Use View decorator from @tsed/platform-views instead.
+ */
+export declare function View(path: string, options?: Object): MethodDecorator;

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/{domain → types/domain}/EndpointMetadata.d.ts

@@ -1,11 +1,6 @@
 import { Type } from "@tsed/core";
 import { ParamMetadata } from "@tsed/platform-params";
-import { JsonEntityStore, JsonEntityStoreOptions, JsonOperation } from "@tsed/schema";
-export interface EndpointConstructorOptions extends JsonEntityStoreOptions {
-    beforeMiddlewares?: Function[];
-    middlewares?: Function[];
-    afterMiddlewares?: Function[];
-}
+import { JsonMethodStore } from "@tsed/schema";
 export interface EndpointViewOptions {
     path: string;
     options: any;
@@ -30,28 +25,13 @@ export interface EndpointRedirectOptions {
  *    }
  *
  */
-export declare class EndpointMetadata extends JsonEntityStore implements EndpointConstructorOptions {
-    beforeMiddlewares: any[];
-    middlewares: any[];
-    afterMiddlewares: any[];
-    constructor(options: EndpointConstructorOptions);
+export declare class EndpointMetadata extends JsonMethodStore {
     get targetName(): string;
     get params(): ParamMetadata[];
-    /**
-     * Return the JsonOperation
-     */
-    get operation(): JsonOperation;
-    get operationPaths(): Map<string, import("@tsed/schema").JsonMethodPath>;
     get view(): EndpointViewOptions;
     set view(view: EndpointViewOptions);
     get acceptMimes(): string[];
     set acceptMimes(mimes: string[]);
-    /**
-     * Get all endpoints from a given class and his parents.
-     * @param {Type<any>} target
-     * @returns {EndpointMetadata[]}
-     */
-    static getEndpoints(target: Type<any>): EndpointMetadata[];
     /**
      * Get an endpoint.
      * @param target
@@ -59,7 +39,7 @@ export declare class EndpointMetadata extends JsonEntityStore implements Endpoin
      * @param descriptor
      */
     static get(target: Type<any>, propertyKey: string | symbol, descriptor?: PropertyDescriptor): EndpointMetadata;
-    addOperationPath(method: string, path: string | RegExp, options?: any): JsonOperation;
+    addOperationPath(method: string, path: string | RegExp, options?: any): import("@tsed/schema").JsonOperation;
     /**
      * Find the a value at the controller level. Let this value be extended or overridden by the endpoint itself.
      *
@@ -67,22 +47,4 @@ export declare class EndpointMetadata extends JsonEntityStore implements Endpoin
      * @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;
-    clone(): EndpointMetadata;
 }

package/lib/{domain → types/domain}/HandlerMetadata.d.ts

@@ -1,6 +1,6 @@
 import { Type } from "@tsed/core";
 import { ProviderScope } from "@tsed/di";
-import { ParamMetadata } from "@tsed/platform-params";
+import { JsonParameterStore } from "@tsed/schema";
 import { HandlerType } from "../interfaces/HandlerType";
 import { PlatformRouteOptions, PlatformRouteWithoutHandlers } from "../interfaces/PlatformRouteOptions";
 export interface HandlerMetadataOptions {
@@ -25,7 +25,7 @@ export declare class HandlerMetadata {
     handler: any;
     constructor(options: HandlerMetadataOptions);
     get hasErrorParam(): boolean;
-    getParams(): ParamMetadata[];
+    getParams(): JsonParameterStore[];
     hasParamType(paramType: any): boolean;
     isFinal(): boolean;
     toString(): string;

package/lib/{domain → types/domain}/PlatformRouteDetails.d.ts

@@ -1,3 +1,4 @@
+import { JsonOperationRoute } from "@tsed/schema";
 import { EndpointMetadata } from "./EndpointMetadata";
 import { ControllerProvider } from "./ControllerProvider";
 export interface PlatformRouterDetailsOptions {
@@ -6,24 +7,17 @@ export interface PlatformRouterDetailsOptions {
     method: string;
     url: string;
 }
-export declare class PlatformRouteDetails {
-    readonly method: string;
-    readonly url: string;
+export declare class PlatformRouteDetails extends JsonOperationRoute<EndpointMetadata> {
     readonly rawBody: boolean;
-    readonly endpoint: EndpointMetadata;
     readonly provider: ControllerProvider;
-    constructor({ provider, endpoint, method, url }: PlatformRouterDetailsOptions);
-    get name(): string;
-    get className(): string;
-    get methodClassName(): string;
-    get parameters(): import("@tsed/platform-params").ParamMetadata[];
+    constructor(options?: Partial<PlatformRouteDetails>);
     toJSON(): {
         method: string;
         name: string;
         url: string;
         className: string;
         methodClassName: string;
-        parameters: import("@tsed/platform-params").ParamMetadata[];
+        parameters: any;
         rawBody: boolean;
     };
 }

package/lib/{index.d.ts → types/index.d.ts}

@@ -1,10 +1,10 @@
+import "@tsed/logger";
 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/platform-views";
 export * from "@tsed/components-scan";
 export * from "@tsed/platform-log-middleware";
 export { $log, Logger } from "@tsed/logger";
@@ -17,6 +17,4 @@ export * from "./interfaces";
 export * from "./middlewares";
 export * from "./domain";
 export * from "./services";
-export * from "./registries/ControllerRegistry";
 export * from "./utils";
-export * from "./PlatformModule";

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

@@ -0,0 +1,19 @@
+import { Type } from "@tsed/core";
+import { IProvider } from "@tsed/di";
+export interface PlatformAdapter<App = TsED.Application, Router = TsED.Router> {
+    /**
+     * Load providers in top priority
+     */
+    readonly providers: IProvider[];
+    /**
+     * Called after the injector instantiation
+     */
+    onInit?: () => any;
+    beforeLoadRoutes?: () => Promise<any>;
+    afterLoadRoutes?: () => Promise<any>;
+    useRouter?: () => any;
+    useContext?: () => any;
+}
+export interface PlatformBuilderSettings<App = TsED.Application, Router = TsED.Router> extends Partial<TsED.Configuration> {
+    adapter?: Type<PlatformAdapter<App, Router>>;
+}

package/lib/{interfaces → types/interfaces}/PlatformRouteOptions.d.ts

@@ -1,12 +1,14 @@
-import { PathType } from "@tsed/di";
+import { Type } from "@tsed/core";
+import { PathType } from "./PathType";
 /**
  * @ignore
  */
 export interface PlatformRouteOptions {
-    method: string;
-    path: PathType;
-    handlers: any[];
+    token?: Type<any>;
+    path?: PathType | undefined;
+    method?: string;
     isFinal?: boolean;
+    handlers: any[];
 }
 /**
  * @ignore

package/lib/{interfaces → types/interfaces}/index.d.ts

@@ -13,5 +13,5 @@ export * from "./OnReady";
 export * from "./OnRequest";
 export * from "./OnResponse";
 export * from "./Route";
-export * from "./PlatformRouterMethods";
 export * from "./IncomingEvent";
+export * from "./PlatformAdapter";