@tsed/common 6.87.1 → 6.89.0

package/lib/index.js

@@ -1,3603 +0,0 @@
-var logger = require('@tsed/logger');
-require('@tsed/logger-file');
-var di = require('@tsed/di');
-var platformParams = require('@tsed/platform-params');
-var platformExceptions = require('@tsed/platform-exceptions');
-var platformResponseFilter = require('@tsed/platform-response-filter');
-var platformCache = require('@tsed/platform-cache');
-var platformMiddlewares = require('@tsed/platform-middlewares');
-var platformViews = require('@tsed/platform-views');
-var componentsScan = require('@tsed/components-scan');
-var platformLogMiddleware = require('@tsed/platform-log-middleware');
-var tslib = require('tslib');
-var core = require('@tsed/core');
-var exceptions = require('@tsed/exceptions');
-var schema = require('@tsed/schema');
-var util = require('util');
-var Http = require('http');
-var Https = require('https');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () {
-            return e[k];
-          }
-        });
-      }
-    });
-  }
-  n['default'] = e;
-  return n;
-}
-
-var Http__default = /*#__PURE__*/_interopDefaultLegacy(Http);
-var Https__default = /*#__PURE__*/_interopDefaultLegacy(Https);
-
-function _extends() {
-  _extends = Object.assign || function (target) {
-    for (var i = 1; i < arguments.length; i++) {
-      var source = arguments[i];
-
-      for (var key in source) {
-        if (Object.prototype.hasOwnProperty.call(source, key)) {
-          target[key] = source[key];
-        }
-      }
-    }
-
-    return target;
-  };
-
-  return _extends.apply(this, arguments);
-}
-
-function _objectWithoutPropertiesLoose(source, excluded) {
-  if (source == null) return {};
-  var target = {};
-  var sourceKeys = Object.keys(source);
-  var key, i;
-
-  for (i = 0; i < sourceKeys.length; i++) {
-    key = sourceKeys[i];
-    if (excluded.indexOf(key) >= 0) continue;
-    target[key] = source[key];
-  }
-
-  return target;
-}
-
-var id = 0;
-
-function _classPrivateFieldLooseKey(name) {
-  return "__private_" + id++ + "_" + name;
-}
-
-function _classPrivateFieldLooseBase(receiver, privateKey) {
-  if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) {
-    throw new TypeError("attempted to use private field on non-instance");
-  }
-
-  return receiver;
-}
-
-var PlatformConfiguration_1;
-const rootDir = process.cwd();
-/**
- * `PlatformConfiguration` contains all information about your Server configuration.
- */
-
-exports.PlatformConfiguration = PlatformConfiguration_1 = class PlatformConfiguration extends di.DIConfiguration {
-  constructor() {
-    super({
-      rootDir
-    });
-  }
-
-  get version() {
-    return this.getRaw("version");
-  }
-
-  set version(v) {
-    this.setRaw("version", v);
-  }
-
-  get rootDir() {
-    return this.getRaw("rootDir");
-  }
-
-  set rootDir(value) {
-    this.setRaw("rootDir", value);
-  }
-
-  get port() {
-    return this.httpPort;
-  }
-
-  set port(value) {
-    this.httpPort = value;
-  }
-
-  get httpsOptions() {
-    return this.getRaw("httpsOptions");
-  }
-
-  set httpsOptions(value) {
-    this.setRaw("httpsOptions", value);
-  }
-
-  get httpPort() {
-    return this.getRaw("httpPort");
-  }
-
-  set httpPort(value) {
-    this.setRaw("httpPort", value);
-  }
-
-  get httpsPort() {
-    return this.getRaw("httpsPort");
-  }
-
-  set httpsPort(value) {
-    this.setRaw("httpsPort", value);
-  }
-
-  get env() {
-    return this.getRaw("env");
-  }
-
-  set env(value) {
-    this.setRaw("env", value);
-  }
-
-  get mount() {
-    return this.get("mount");
-  }
-
-  set mount(value) {
-    this.setRaw("mount", value);
-  }
-
-  get componentsScan() {
-    return this.resolve(this.getRaw("componentsScan"));
-  }
-
-  set componentsScan(value) {
-    this.setRaw("componentsScan", value);
-  }
-
-  get statics() {
-    return this.getRaw("statics") || this.getRaw("serveStatic") || {};
-  }
-
-  set statics(value) {
-    this.setRaw("statics", value);
-  }
-
-  get acceptMimes() {
-    return this.getRaw("acceptMimes");
-  }
-
-  set acceptMimes(value) {
-    this.setRaw("acceptMimes", value || []);
-  }
-
-  get debug() {
-    return this.logger.level === "debug";
-  }
-
-  set debug(debug) {
-    this.logger = _extends({}, this.logger, {
-      level: debug ? "debug" : "info"
-    });
-  }
-
-  get converter() {
-    return this.get("converter") || {};
-  }
-
-  set converter(options) {
-    this.setRaw("converter", options);
-  }
-
-  get logger() {
-    return this.get("logger");
-  }
-
-  set logger(value) {
-    const logger$1 = _extends({}, this.logger, value);
-
-    logger$1.debug = logger$1.level === "debug";
-    this.setRaw("logger", logger$1);
-    this.setRaw("debug", logger$1.debug);
-
-    if (logger$1.format) {
-      logger.$log.appenders.set("stdout", {
-        type: "stdout",
-        levels: ["info", "debug"],
-        layout: {
-          type: "pattern",
-          pattern: logger$1.format
-        }
-      });
-      logger.$log.appenders.set("stderr", {
-        levels: ["trace", "fatal", "error", "warn"],
-        type: "stderr",
-        layout: {
-          type: "pattern",
-          pattern: logger$1.format
-        }
-      });
-    }
-  }
-
-  get exclude() {
-    return this.get("exclude");
-  }
-
-  set exclude(exclude) {
-    this.setRaw("exclude", exclude);
-  }
-  /**
-   *
-   * @param addressPort
-   * @returns {{address: string, port: number}}
-   */
-
-
-  static buildAddressAndPort(addressPort) {
-    let address = "0.0.0.0";
-    let port = addressPort;
-
-    if (typeof addressPort === "string" && addressPort.indexOf(":") > -1) {
-      [address, port] = addressPort.split(":");
-      port = +port;
-    }
-
-    return {
-      address,
-      port: port
-    };
-  }
-  /**
-   *
-   * @returns {string|number}
-   */
-
-
-  getHttpPort() {
-    return PlatformConfiguration_1.buildAddressAndPort(this.getRaw("httpPort"));
-  }
-  /**
-   *
-   * @param settings
-   */
-
-
-  setHttpPort(settings) {
-    this.setRaw("httpPort", `${settings.address}:${settings.port}`);
-  }
-  /**
-   *
-   * @returns {string|number}
-   */
-
-
-  getHttpsPort() {
-    return PlatformConfiguration_1.buildAddressAndPort(this.getRaw("httpsPort"));
-  }
-  /**
-   *
-   * @param settings
-   */
-
-
-  setHttpsPort(settings) {
-    this.setRaw("httpsPort", `${settings.address}:${settings.port}`);
-  }
-
-  getBestHost() {
-    const {
-      httpsPort,
-      httpPort
-    } = this;
-
-    if (httpsPort) {
-      const host = this.getHttpsPort();
-      return _extends({
-        protocol: "https"
-      }, host);
-    }
-
-    if (httpPort) {
-      const host = this.getHttpPort();
-      return _extends({
-        protocol: "http"
-      }, host);
-    }
-  }
-
-};
-exports.PlatformConfiguration = PlatformConfiguration_1 = tslib.__decorate([di.Injectable({
-  scope: di.ProviderScope.SINGLETON,
-  global: true
-}), tslib.__metadata("design:paramtypes", [])], exports.PlatformConfiguration);
-
-/**
- * @ignore
- */
-function bindEndpointMiddleware(endpoint) {
-  return ctx => {
-    ctx.endpoint = endpoint;
-  };
-}
-
-/**
- * @ignore
- */
-const createFakeRawDriver = () => {
-  // istanbul ignore next
-  function FakeRawDriver() {} // istanbul ignore next
-
-
-  function use() {
-    return this;
-  }
-
-  FakeRawDriver.use = use;
-  FakeRawDriver.all = use;
-  FakeRawDriver.get = use;
-  FakeRawDriver.patch = use;
-  FakeRawDriver.post = use;
-  FakeRawDriver.put = use;
-  FakeRawDriver.head = use;
-  FakeRawDriver.delete = use;
-  FakeRawDriver.options = use;
-  return FakeRawDriver;
-};
-
-class AnyToPromiseWithCtx extends core.AnyToPromise {
-  constructor({
-    $ctx,
-    err
-  }) {
-    super();
-    this.$ctx = $ctx;
-    this.err = err;
-  }
-
-  isDone() {
-    const {
-      $ctx
-    } = this;
-
-    if (!($ctx != null && $ctx.isDone())) {
-      if ($ctx != null && $ctx.request.isAborted() || $ctx != null && $ctx.response.isDone()) {
-        this.destroy();
-
-        if (this.status === core.AnyToPromiseStatus.PENDING) {
-          this.status = core.AnyToPromiseStatus.RESOLVED;
-        }
-      }
-    }
-
-    return super.isDone();
-  }
-
-  async call(cb) {
-    return super.call(() => cb(this));
-  }
-
-  destroy() {
-    // @ts-ignore
-    delete this.$ctx;
-  }
-
-  isCanceledResponse(process) {
-    return process === this.$ctx.getResponse();
-  }
-
-}
-
-/**
- * @ignore
- */
-exports.HandlerType = void 0;
-
-(function (HandlerType) {
-  HandlerType["CUSTOM"] = "custom";
-  HandlerType["ENDPOINT"] = "endpoint";
-  HandlerType["MIDDLEWARE"] = "middleware";
-  HandlerType["ERR_MIDDLEWARE"] = "err:middleware";
-  HandlerType["CTX_FN"] = "context";
-  HandlerType["RAW_FN"] = "raw:middleware";
-  HandlerType["RAW_ERR_FN"] = "raw:err:middleware";
-})(exports.HandlerType || (exports.HandlerType = {}));
-
-class HandlerMetadata {
-  constructor(options) {
-    this.injectable = false;
-    this.type = exports.HandlerType.RAW_FN;
-    this.hasNextFunction = false;
-    const {
-      target,
-      token,
-      propertyKey,
-      type,
-      scope,
-      routeOptions
-    } = options;
-    this.type = type || target.type || exports.HandlerType.RAW_FN;
-    this.scope = scope || di.ProviderScope.SINGLETON;
-    this.routeOptions = routeOptions || {};
-    const handler = propertyKey ? target.prototype[propertyKey] : target;
-
-    if (propertyKey) {
-      this.target = target;
-      this.token = token;
-      this.propertyKey = propertyKey;
-      this.hasNextFunction = this.hasParamType(platformParams.ParamTypes.NEXT_FN);
-
-      if (this.hasParamType(platformParams.ParamTypes.ERR)) {
-        this.type = exports.HandlerType.ERR_MIDDLEWARE;
-      }
-
-      this.injectable = schema.JsonParameterStore.getParams(target, propertyKey).length > 0;
-    } else {
-      this.handler = handler;
-    }
-
-    if (!this.injectable) {
-      if (handler.length === 4) {
-        this.type = exports.HandlerType.RAW_ERR_FN;
-      }
-
-      this.hasNextFunction = handler.length >= 3;
-    }
-  }
-
-  get hasErrorParam() {
-    return this.type === exports.HandlerType.ERR_MIDDLEWARE || this.type === exports.HandlerType.RAW_ERR_FN;
-  }
-
-  getParams() {
-    return schema.JsonParameterStore.getParams(this.target, this.propertyKey) || [];
-  }
-
-  hasParamType(paramType) {
-    return this.getParams().findIndex(p => p.paramType === paramType) > -1;
-  }
-
-  isFinal() {
-    var _this$routeOptions;
-
-    return ((_this$routeOptions = this.routeOptions) == null ? void 0 : _this$routeOptions.isFinal) || false;
-  }
-
-  toString() {
-    return [this.target && core.nameOf(this.target), this.propertyKey].filter(Boolean).join(".");
-  }
-
-}
-
-/**
- * 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(){}
- *    }
- *
- */
-
-exports.EndpointMetadata = class EndpointMetadata extends schema.JsonMethodStore {
-  constructor(options) {
-    super(_extends({
-      store: core.Store.fromMethod(options.target, options.propertyKey),
-      descriptor: core.descriptorOf(options.target, options.propertyKey)
-    }, options));
-    this.beforeMiddlewares = [];
-    this.middlewares = [];
-    this.afterMiddlewares = [];
-    const {
-      beforeMiddlewares = [],
-      middlewares = [],
-      afterMiddlewares = []
-    } = options;
-    this.after(afterMiddlewares);
-    this.before(beforeMiddlewares);
-    this.use(middlewares);
-  }
-
-  get targetName() {
-    return core.nameOf(this.token);
-  }
-
-  get params() {
-    return this.parameters;
-  }
-
-  get view() {
-    return this.store.get("view");
-  }
-
-  set view(view) {
-    this.store.set("view", view);
-  }
-
-  get acceptMimes() {
-    return this.store.get("acceptMimes", []);
-  }
-
-  set acceptMimes(mimes) {
-    this.store.set("acceptMimes", mimes);
-  }
-  /**
-   * Get an endpoint.
-   * @param target
-   * @param propertyKey
-   * @param descriptor
-   */
-
-
-  static get(target, propertyKey, descriptor) {
-    descriptor = descriptor || core.descriptorOf(core.prototypeOf(target), propertyKey);
-    return schema.JsonEntityStore.from(core.prototypeOf(target), propertyKey, descriptor);
-  }
-
-  addOperationPath(method, path, options = {}) {
-    return this.operation.addOperationPath(method, path, options);
-  }
-  /**
-   * Find the a value at the controller level. Let this value be extended or overridden by the endpoint itself.
-   *
-   * @param key
-   * @returns {any}
-   */
-
-
-  get(key) {
-    const ctrlValue = core.Store.from(this.target).get(key);
-    return core.deepMerge(ctrlValue, this.store.get(key));
-  }
-  /**
-   * Append middlewares to the beforeMiddlewares list.
-   * @param args
-   * @returns {EndpointMetadata}
-   */
-
-
-  before(args) {
-    this.beforeMiddlewares = this.beforeMiddlewares.concat(args).filter(core.isFunction);
-    return this;
-  }
-  /**
-   * Append middlewares to the afterMiddlewares list.
-   * @param args
-   * @returns {EndpointMetadata}
-   */
-
-
-  after(args) {
-    this.afterMiddlewares = this.afterMiddlewares.concat(args).filter(core.isFunction);
-    return this;
-  }
-  /**
-   * Store all arguments collected via Annotation.
-   * @param args
-   */
-
-
-  use(args) {
-    this.middlewares = this.middlewares.concat(args).filter(core.isFunction);
-    return this;
-  }
-
-};
-exports.EndpointMetadata = tslib.__decorate([schema.JsonEntityComponent(core.DecoratorTypes.METHOD), tslib.__metadata("design:paramtypes", [Object])], exports.EndpointMetadata);
-
-function isMetadata(input) {
-  return input instanceof HandlerMetadata;
-}
-/**
- * @ignore
- */
-
-
-function createHandlerMetadata(injector, obj, routeOptions = {}) {
-  if (isMetadata(obj)) {
-    return obj;
-  }
-
-  let options;
-
-  if (obj instanceof exports.EndpointMetadata) {
-    const provider = injector.getProvider(routeOptions.token);
-    options = {
-      token: provider.token,
-      target: provider.useClass,
-      scope: provider.scope,
-      type: exports.HandlerType.ENDPOINT,
-      propertyKey: obj.propertyKey
-    };
-  } else {
-    const provider = injector.getProvider(obj);
-
-    if (provider) {
-      options = {
-        token: provider.token,
-        target: provider.useClass,
-        scope: provider.scope,
-        type: exports.HandlerType.MIDDLEWARE,
-        propertyKey: "use"
-      };
-    } else {
-      options = {
-        target: obj
-      };
-    }
-  }
-
-  options.routeOptions = routeOptions;
-  return new HandlerMetadata(options);
-}
-
-function mergeHeaders(specHeaders, headers) {
-  return Object.entries(specHeaders).reduce((headers, [key, item]) => {
-    key = key.toLowerCase();
-    return _extends({}, headers, {
-      [key]: headers[key] === undefined ? String(item.example) : headers[key]
-    });
-  }, headers);
-}
-/**
- * @ignore
- */
-
-
-function setResponseHeaders(ctx) {
-  const {
-    response,
-    endpoint
-  } = ctx;
-  const {
-    operation
-  } = endpoint;
-
-  if (response.isDone()) {
-    return;
-  }
-
-  if (!response.hasStatus()) {
-    // apply status only if the isn't already modified
-    response.status(operation.getStatus());
-  }
-
-  const statusCode = response.statusCode;
-  const headers = operation.getHeadersOf(response.statusCode);
-  const mergedHeaders = mergeHeaders(headers, response.getHeaders());
-  response.setHeaders(mergedHeaders);
-
-  if (operation.isRedirection(statusCode)) {
-    response.redirect(statusCode, String(mergedHeaders["location"]));
-  }
-}
-
-/**
- * Platform Handler abstraction layer. Wrap original class method to a pure platform handler (Express, Koa, etc...).
- * @platform
- */
-
-exports.PlatformHandler = class PlatformHandler {
-  constructor(injector, params) {
-    this.injector = injector;
-    this.params = params;
-  }
-  /**
-   * Create a native middleware based on the given metadata and return an instance of AnyToPromiseWithCtx
-   * @param input
-   * @param options
-   */
-
-
-  createHandler(input, options = {}) {
-    return this.createRawHandler(createHandlerMetadata(this.injector, input, options));
-  }
-  /**
-   * Create injectable handler from the given provider
-   * @param provider
-   * @param propertyKey
-   */
-
-
-  createCustomHandler(provider, propertyKey) {
-    const handler = this.compileHandler(new HandlerMetadata({
-      token: provider.provide,
-      target: provider.useClass,
-      type: exports.HandlerType.CUSTOM,
-      scope: provider.scope,
-      propertyKey
-    }));
-    return async ($ctx, next) => handler({
-      $ctx,
-      next
-    });
-  }
-  /**
-   * Send the response to the consumer.
-   * @param data
-   * @param ctx
-   * @protected
-   */
-
-
-  async flush(data, ctx) {
-    const {
-      response
-    } = ctx;
-
-    if (!response.isDone()) {
-      data = await this.responseFilter.serialize(data, ctx);
-      data = await this.responseFilter.transform(data, ctx);
-      response.body(data);
-    }
-  }
-
-  compileHandler(metadata) {
-    if (metadata.type === exports.HandlerType.CTX_FN) {
-      return async scope => {
-        // @ts-ignore
-        return this.onCtxRequest(_extends({}, scope, {
-          handler: () => metadata.handler(scope.$ctx),
-          metadata
-        }));
-      };
-    }
-
-    const promise = this.params.compileHandler({
-      token: metadata.token,
-      propertyKey: metadata.propertyKey,
-      getCustomArgs: metadata.injectable ? undefined : this.getDefaultArgs(metadata)
-    });
-    return async scope => {
-      const handler = await promise; // @ts-ignore
-
-      return this.onRequest(_extends({}, scope, {
-        handler,
-        metadata
-      }));
-    };
-  }
-
-  async onCtxRequest(requestOptions) {
-    await requestOptions.handler(requestOptions);
-    return this.next(requestOptions);
-  }
-  /**
-   * Call handler when a request his handle
-   * @param requestOptions
-   */
-
-
-  async onRequest(requestOptions) {
-    const {
-      $ctx,
-      metadata,
-      err,
-      handler
-    } = requestOptions; // istanbul ignore next
-
-    if (!$ctx) {
-      logger.$log.error({
-        name: "HEADERS_SENT",
-        message: `An endpoint is called but the response is already send to the client. The call comes from the handler: ${metadata.toString()}`
-      });
-      return;
-    }
-
-    const resolver = new AnyToPromiseWithCtx({
-      $ctx,
-      err
-    });
-    return this.injector.runInContext($ctx, async () => {
-      try {
-        const {
-          state,
-          data,
-          status,
-          headers
-        } = await resolver.call(handler);
-
-        if (state === core.AnyToPromiseStatus.RESOLVED) {
-          if (status) {
-            $ctx.response.status(status);
-          }
-
-          if (headers) {
-            $ctx.response.setHeaders(headers);
-          }
-
-          if (data !== undefined) {
-            $ctx.data = data;
-          } // Can be canceled by the handler itself
-
-
-          return await this.onSuccess($ctx.data, requestOptions);
-        }
-      } catch (er) {
-        return this.onError(er, requestOptions);
-      }
-    });
-  }
-
-  async onError(er, requestOptions) {
-    var _$ctx$response;
-
-    const {
-      next,
-      $ctx,
-      metadata
-    } = requestOptions;
-    $ctx.data = er;
-
-    if (!next) {
-      throw er;
-    } // istanbul ignore next
-
-
-    if (!($ctx != null && (_$ctx$response = $ctx.response) != null && _$ctx$response.isHeadersSent) || $ctx.response.isHeadersSent()) {
-      logger.$log.warn({
-        name: "HEADERS_SENT",
-        message: `An error was caught after the headers were sent to the client. The error comes from the handler: ${metadata.toString()}`,
-        stack: er.stack,
-        origin: er,
-        request_id: $ctx.id
-      });
-      return;
-    }
-
-    return next && next(er);
-  }
-  /**
-   * Manage success scenario
-   * @param data
-   * @param requestOptions
-   * @protected
-   */
-
-
-  async onSuccess(data, requestOptions) {
-    const {
-      metadata,
-      $ctx,
-      next
-    } = requestOptions; // TODO see this control is necessary
-    // istanbul ignore next
-
-    if ($ctx.request.isAborted() || $ctx.response.isDone()) {
-      return;
-    } // set headers each times that an endpoint is called
-
-
-    if (metadata.type === exports.HandlerType.ENDPOINT) {
-      this.setHeaders($ctx);
-    } // call returned middleware
-
-
-    if (core.isFunction(data) && !core.isStream(data)) {
-      return this.callReturnedMiddleware(data, $ctx, next);
-    }
-
-    if (metadata.isFinal()) {
-      return this.flush(data, $ctx);
-    }
-
-    return this.next(requestOptions);
-  }
-  /**
-   * Call the returned middleware by the handler.
-   * @param middleware
-   * @param ctx
-   * @param next
-   * @protected
-   */
-
-
-  callReturnedMiddleware(middleware, ctx, next) {
-    return middleware(ctx.getRequest(), ctx.getResponse(), next);
-  }
-  /**
-   * create Raw handler
-   * @param metadata
-   */
-
-
-  createRawHandler(metadata) {
-    if ([exports.HandlerType.RAW_ERR_FN, exports.HandlerType.RAW_FN].includes(metadata.type)) {
-      return metadata.handler;
-    }
-
-    const handler = this.compileHandler(metadata);
-    return async (request, response, next) => {
-      return handler({
-        next,
-        $ctx: request.$ctx
-      });
-    };
-  }
-  /**
-   * Set response headers
-   * @param ctx
-   * @protected
-   */
-
-
-  setHeaders(ctx) {
-    return setResponseHeaders(ctx);
-  }
-
-  next(requestOptions) {
-    const {
-      $ctx,
-      next
-    } = requestOptions;
-    return !$ctx.response.isDone() && next && next();
-  }
-
-  getDefaultArgs(metadata) {
-    return async scope => [metadata.hasErrorParam && scope.err, scope.$ctx.request.request, scope.$ctx.response.response, metadata.hasNextFunction && scope.next].filter(Boolean);
-  }
-
-};
-
-tslib.__decorate([di.Inject(), tslib.__metadata("design:type", platformResponseFilter.PlatformResponseFilter)], exports.PlatformHandler.prototype, "responseFilter", void 0);
-
-exports.PlatformHandler = tslib.__decorate([di.Injectable({
-  scope: di.ProviderScope.SINGLETON
-}), tslib.__metadata("design:paramtypes", [di.InjectorService, platformParams.PlatformParams])], exports.PlatformHandler);
-
-const _excluded$3 = ["method", "path", "handlers"];
-var PlatformRouter_1;
-/**
- * @ignore
- */
-
-const PLATFORM_ROUTER_OPTIONS = Symbol.for("PlatformRouterOptions");
-/**
- * Platform Router abstraction layer.
- * @platform
- */
-
-exports.PlatformRouter = PlatformRouter_1 = class PlatformRouter {
-  constructor(platformHandler) {
-    this.platformHandler = platformHandler;
-    this.isBuilt = false;
-    this.rawRouter = this.raw = PlatformRouter_1.createRawRouter();
-  }
-  /**
-   * Create a new instance of PlatformRouter
-   * @param injector
-   * @param routerOptions
-   */
-
-
-  static create(injector, routerOptions = {}) {
-    const locals = new Map();
-    locals.set(PLATFORM_ROUTER_OPTIONS, routerOptions);
-    return injector.invoke(PlatformRouter_1, locals);
-  }
-
-  static createRawRouter() {
-    return createFakeRawDriver();
-  }
-
-  callback() {
-    return this.raw;
-  }
-
-  getRouter() {
-    return this.rawRouter;
-  }
-
-  use(...handlers) {
-    // @ts-ignore
-    this.getRouter().use(...this.mapHandlers(handlers));
-    return this;
-  }
-
-  addRoute(options) {
-    const {
-      method,
-      path,
-      handlers
-    } = options,
-          opts = _objectWithoutPropertiesLoose(options, _excluded$3); // @ts-ignore
-
-
-    this.getRouter()[method](path, ...this.mapHandlers(handlers, _extends({
-      method,
-      path
-    }, opts)));
-    return this;
-  }
-
-  all(path, ...handlers) {
-    return this.addRoute({
-      method: "all",
-      path,
-      handlers,
-      isFinal: true
-    });
-  }
-
-  get(path, ...handlers) {
-    return this.addRoute({
-      method: "get",
-      path,
-      handlers,
-      isFinal: true
-    });
-  }
-
-  post(path, ...handlers) {
-    return this.addRoute({
-      method: "post",
-      path,
-      handlers,
-      isFinal: true
-    });
-  }
-
-  put(path, ...handlers) {
-    return this.addRoute({
-      method: "put",
-      path,
-      handlers,
-      isFinal: true
-    });
-  }
-
-  delete(path, ...handlers) {
-    return this.addRoute({
-      method: "delete",
-      path,
-      handlers,
-      isFinal: true
-    });
-  }
-
-  patch(path, ...handlers) {
-    return this.addRoute({
-      method: "patch",
-      path,
-      handlers,
-      isFinal: true
-    });
-  }
-
-  head(path, ...handlers) {
-    return this.addRoute({
-      method: "head",
-      path,
-      handlers,
-      isFinal: true
-    });
-  }
-
-  options(path, ...handlers) {
-    return this.addRoute({
-      method: "options",
-      path,
-      handlers,
-      isFinal: true
-    });
-  }
-
-  statics(path, options) {
-    return this;
-  }
-
-  multer(options) {
-    const m = require("multer")(options);
-
-    const makePromise = (multer, name) => {
-      // istanbul ignore next
-      if (!multer[name]) return;
-      const fn = multer[name];
-
-      multer[name] = function apply(...args) {
-        const middleware = Reflect.apply(fn, this, args);
-        return (req, res) => util.promisify(middleware)(req, res);
-      };
-    };
-
-    makePromise(m, "any");
-    makePromise(m, "array");
-    makePromise(m, "fields");
-    makePromise(m, "none");
-    makePromise(m, "single");
-    return m;
-  }
-
-  mapHandlers(handlers, options = {}) {
-    return handlers.reduce((list, handler, index) => {
-      if (typeof handler === "string") {
-        return list.concat(handler);
-      }
-
-      if (handler instanceof PlatformRouter_1) {
-        return list.concat(handler.callback());
-      }
-
-      return list.concat(this.platformHandler.createHandler(handler, _extends({}, options, {
-        isFinal: options.isFinal ? index === handlers.length - 1 : false
-      })));
-    }, []);
-  }
-
-};
-
-tslib.__decorate([di.Inject(), tslib.__metadata("design:type", di.InjectorService)], exports.PlatformRouter.prototype, "injector", void 0);
-
-exports.PlatformRouter = PlatformRouter_1 = tslib.__decorate([di.Injectable({
-  scope: di.ProviderScope.INSTANCE
-}), tslib.__metadata("design:paramtypes", [exports.PlatformHandler])], exports.PlatformRouter);
-
-var PlatformApplication_1;
-/**
- * `PlatformApplication` is used to provide all routes collected by annotation `@Controller`.
- *
- * @platform
- */
-
-exports.PlatformApplication = PlatformApplication_1 = class PlatformApplication extends exports.PlatformRouter {
-  constructor(platformHandler) {
-    super(platformHandler);
-    this.rawApp = this.raw = PlatformApplication_1.createRawApp();
-  }
-
-  static createRawApp() {
-    return createFakeRawDriver();
-  }
-
-  getApp() {
-    return this.raw;
-  }
-
-};
-exports.PlatformApplication = PlatformApplication_1 = tslib.__decorate([di.Injectable({
-  scope: di.ProviderScope.SINGLETON
-}), tslib.__metadata("design:paramtypes", [exports.PlatformHandler])], exports.PlatformApplication);
-
-var PlatformMulterMiddleware_1;
-/**
- * @middleware
- */
-
-exports.PlatformMulterMiddleware = PlatformMulterMiddleware_1 = class PlatformMulterMiddleware {
-  async use(ctx) {
-    try {
-      const {
-        fields,
-        options = {}
-      } = ctx.endpoint.get(PlatformMulterMiddleware_1);
-
-      const settings = _extends({}, this.settings, options);
-      /* istanbul ignore next */
-
-
-      if (settings.storage) {
-        delete settings.dest;
-      }
-
-      const middleware = this.app.multer(settings).fields(this.getFields({
-        fields
-      }));
-      return await middleware(ctx.getRequest(), ctx.getResponse());
-    } catch (er) {
-      throw er.code ? new exceptions.Exception(er.code, `${er.message} ${er.field || ""}`.trim()) : er;
-    }
-  }
-
-  getFields(conf) {
-    return conf.fields.map(({
-      name,
-      maxCount
-    }) => ({
-      name,
-      maxCount
-    }));
-  }
-
-};
-
-tslib.__decorate([di.Constant("multer", {}), tslib.__metadata("design:type", Object)], exports.PlatformMulterMiddleware.prototype, "settings", void 0);
-
-tslib.__decorate([di.Inject(), tslib.__metadata("design:type", exports.PlatformApplication)], exports.PlatformMulterMiddleware.prototype, "app", void 0);
-
-tslib.__decorate([tslib.__param(0, platformParams.Context()), tslib.__metadata("design:type", Function), tslib.__metadata("design:paramtypes", [Object]), tslib.__metadata("design:returntype", Promise)], exports.PlatformMulterMiddleware.prototype, "use", null);
-
-exports.PlatformMulterMiddleware = PlatformMulterMiddleware_1 = tslib.__decorate([platformMiddlewares.Middleware()], exports.PlatformMulterMiddleware);
-
-/**
- * @deprecated Since 2020-11-30. Use PlatformAcceptMimesMiddleware.
- * @ignore
- */
-
-exports.GlobalAcceptMimesMiddleware = class GlobalAcceptMimesMiddleware {
-  use(ctx) {
-    return;
-  }
-
-};
-
-tslib.__decorate([tslib.__param(0, platformParams.Context()), tslib.__metadata("design:type", Function), tslib.__metadata("design:paramtypes", [Object]), tslib.__metadata("design:returntype", void 0)], exports.GlobalAcceptMimesMiddleware.prototype, "use", null);
-
-exports.GlobalAcceptMimesMiddleware = tslib.__decorate([platformMiddlewares.Middleware()], exports.GlobalAcceptMimesMiddleware);
-
-/**
- * @middleware
- * @platform
- */
-
-exports.PlatformAcceptMimesMiddleware = class PlatformAcceptMimesMiddleware {
-  use(ctx) {
-    const {
-      endpoint,
-      request
-    } = ctx;
-    const mimes = core.uniq(((endpoint == null ? void 0 : endpoint.get("acceptMimes")) || []).concat(this.acceptMimes));
-
-    if (mimes.length && !request.accepts(mimes)) {
-      throw new exceptions.NotAcceptable(mimes.join(", "));
-    }
-  }
-
-};
-
-tslib.__decorate([di.Constant("acceptMimes", []), tslib.__metadata("design:type", Array)], exports.PlatformAcceptMimesMiddleware.prototype, "acceptMimes", void 0);
-
-tslib.__decorate([tslib.__param(0, platformParams.Context()), tslib.__metadata("design:type", Function), tslib.__metadata("design:paramtypes", [Object]), tslib.__metadata("design:returntype", void 0)], exports.PlatformAcceptMimesMiddleware.prototype, "use", null);
-
-exports.PlatformAcceptMimesMiddleware = tslib.__decorate([platformMiddlewares.Middleware()], exports.PlatformAcceptMimesMiddleware);
-
-/**
- * @middleware
- * @deprecated Since 2020-11-30. Use PlatformAcceptMimesMiddleware.
- * @ignore
- */
-
-exports.AcceptMimesMiddleware = class AcceptMimesMiddleware {
-  use(ctx) {
-    return;
-  }
-
-};
-
-tslib.__decorate([tslib.__param(0, platformParams.Context()), tslib.__metadata("design:type", Function), tslib.__metadata("design:paramtypes", [Object]), tslib.__metadata("design:returntype", void 0)], exports.AcceptMimesMiddleware.prototype, "use", null);
-
-exports.AcceptMimesMiddleware = tslib.__decorate([platformMiddlewares.Middleware()], exports.AcceptMimesMiddleware);
-
-const ROUTER_OPTIONS = Symbol.for("ROUTER_OPTIONS");
-
-let AUTO_INC = 0;
-class ControllerProvider extends di.Provider {
-  constructor(provide, options = {}) {
-    super(provide, options);
-    this.type = di.ProviderType.CONTROLLER;
-    this.tokenRouter = `${this.name}_ROUTER_${AUTO_INC++}`;
-  }
-  /**
-   *
-   */
-
-
-  get routerOptions() {
-    return this.store.get(ROUTER_OPTIONS) || {};
-  }
-  /**
-   *
-   * @param value
-   */
-
-
-  set routerOptions(value) {
-    this.store.set(ROUTER_OPTIONS, value);
-  }
-  /**
-   *
-   * @returns {any[]}
-   */
-
-
-  get middlewares() {
-    return Object.assign({
-      use: [],
-      useAfter: [],
-      useBefore: []
-    }, this.store.get("middlewares", {}));
-  }
-  /**
-   *
-   * @param middlewares
-   */
-
-
-  set middlewares(middlewares) {
-    const mdlwrs = this.middlewares;
-
-    const concat = (key, a, b) => a[key] = a[key].concat(b[key]);
-
-    Object.keys(middlewares).forEach(key => {
-      concat(key, mdlwrs, middlewares);
-    });
-    this.store.set("middlewares", mdlwrs);
-  }
-
-}
-
-/**
- * Create Ts.ED context handler
- * @param fn
- * @ignore
- */
-
-function useCtxHandler(fn) {
-  fn.type = exports.HandlerType.CTX_FN;
-  return fn;
-}
-
-exports.PlatformMiddlewaresChain = class PlatformMiddlewaresChain {
-  get(provider, operationRoute) {
-    const {
-      endpoint
-    } = operationRoute;
-    const {
-      beforeMiddlewares,
-      middlewares: mldwrs,
-      afterMiddlewares
-    } = endpoint;
-    const {
-      middlewares: {
-        use,
-        useAfter
-      }
-    } = provider;
-    const hasFiles = [...operationRoute.endpoint.children.values()].find(item => item.paramType === platformParams.ParamTypes.FILES);
-    return [].concat(useCtxHandler(bindEndpointMiddleware(endpoint))).concat(exports.PlatformAcceptMimesMiddleware).concat(hasFiles && exports.PlatformMulterMiddleware).concat(beforeMiddlewares) // Endpoint before-middlewares
-    .concat(use) // Controller use-middlewares
-    .concat(mldwrs) // Endpoint middlewares
-    .concat(endpoint) // Endpoint metadata
-    .concat(afterMiddlewares) // Endpoint after-middlewares
-    .concat(useAfter) // Controller after middlewares (equivalent to afterEach)
-    .filter(item => !!item);
-  }
-
-};
-exports.PlatformMiddlewaresChain = tslib.__decorate([di.Injectable()], exports.PlatformMiddlewaresChain);
-
-di.GlobalProviders.createRegistry(di.ProviderType.CONTROLLER, ControllerProvider, {
-  onInvoke(provider, locals, {
-    injector
-  }) {
-    const router = createRouter(injector, provider);
-    locals.set(exports.PlatformRouter, router);
-  }
-
-});
-/**
- * @ignore
- */
-
-function formatMethod(method) {
-  return (method === schema.OperationMethods.CUSTOM ? "use" : method || "use").toLowerCase();
-}
-/**
- * @ignore
- */
-
-
-function getRouter(injector, provider) {
-  return injector.get(provider.tokenRouter);
-}
-/**
- * @ignore
- */
-
-function createRouter(injector, provider) {
-  const token = provider.tokenRouter;
-
-  if (injector.has(token)) {
-    return getRouter(injector, provider);
-  }
-
-  const router = exports.PlatformRouter.create(injector, provider.routerOptions);
-  return injector.add(token, {
-    useValue: router
-  }).invoke(token);
-}
-/**
- * @ignore
- * @param injector
- * @param provider
- */
-
-function buildRouter(injector, provider) {
-  const {
-    middlewares: {
-      useBefore
-    },
-    children
-  } = provider; // Controller lifecycle
-
-  const router = createRouter(injector, provider);
-
-  if (!router.isBuilt) {
-    router.isBuilt = true;
-    const platformMiddlewaresChain = injector.get(exports.PlatformMiddlewaresChain);
-    useBefore // Controller before-middleware
-    .filter(o => typeof o === "function").forEach(middleware => {
-      router.use(middleware);
-    }); // build all endpoints and his middlewares
-
-    schema.getOperationsRoutes(provider.token).forEach(operationRoute => {
-      const handlers = platformMiddlewaresChain == null ? void 0 : platformMiddlewaresChain.get(provider, operationRoute);
-      router.addRoute({
-        handlers,
-        token: operationRoute.token,
-        method: formatMethod(operationRoute.method),
-        path: operationRoute.path,
-        isFinal: operationRoute.isFinal
-      });
-    }); // build children controllers
-
-    children.forEach(child => {
-      const childProvider = injector.getProvider(child);
-      /* istanbul ignore next */
-
-      if (!childProvider) {
-        throw new Error("Controller component not found in the ControllerRegistry");
-      }
-
-      router.use(childProvider.path, buildRouter(injector, childProvider));
-    });
-  }
-
-  return router;
-}
-
-/**
- * Platform Request abstraction layer.
- * @platform
- */
-
-exports.PlatformRequest = class PlatformRequest {
-  constructor({
-    request
-  }) {
-    this.raw = request;
-  }
-
-  get secure() {
-    return this.raw.secure;
-  }
-
-  get host() {
-    return this.get("host");
-  }
-
-  get protocol() {
-    return this.raw.protocol;
-  }
-  /**
-   * Get the url of the request.
-   *
-   * Is equivalent of `express.response.originalUrl || express.response.url`.
-   */
-
-
-  get url() {
-    return this.raw.originalUrl || this.raw.url;
-  }
-
-  get headers() {
-    return this.raw.headers;
-  }
-
-  get method() {
-    return this.raw.method;
-  }
-  /**
-   * Contains key-value pairs of data submitted in the request body. By default, it is `undefined`, and is populated when you use
-   * `body-parsing` middleware such as `express.json()` or `express.urlencoded()`.
-   */
-
-
-  get body() {
-    return this.raw.body;
-  }
-
-  get rawBody() {
-    return this.raw.rawBody || this.raw.body;
-  }
-  /**
-   * When using `cookie-parser` middleware, this property is an object that contains cookies sent by the request.
-   * If the request contains no cookies, it defaults to `{}`.
-   */
-
-
-  get cookies() {
-    return this.raw.cookies;
-  }
-  /**
-   * This property is an object containing properties mapped to the named route `parameters`.
-   * For example, if you have the route `/user/:name`, then the `name` property is available as `req.params.name`.
-   * This object defaults to `{}`.
-   */
-
-
-  get params() {
-    return this.raw.params;
-  }
-  /**
-   * This property is an object containing a property for each query string parameter in the route.
-   * When query parser is set to disabled, it is an empty object `{}`, otherwise it is the result of the configured query parser.
-   */
-
-
-  get query() {
-    return this.raw.query;
-  }
-  /**
-   * This property is an object containing a property for each session attributes set by any code.
-   * It require to install a middleware like express-session to work.
-   */
-
-
-  get session() {
-    return this.raw.session;
-  }
-
-  get files() {
-    return this.raw.files;
-  }
-  /**
-   * Return the original request framework instance
-   */
-
-
-  get request() {
-    return this.getRequest();
-  }
-  /**
-   * Return the original request node.js instance
-   */
-
-
-  get req() {
-    return this.getReq();
-  }
-  /**
-   * Returns the HTTP request header specified by field. The match is case-insensitive.
-   *
-   * ```typescript
-   * request.get('Content-Type') // => "text/plain"
-   * ```
-   *
-   * @param name
-   */
-
-
-  get(name) {
-    return this.raw.get(name);
-  }
-
-  accepts(mime) {
-    // @ts-ignore
-    return this.raw.accepts(mime);
-  }
-
-  isAborted() {
-    return this.raw.aborted;
-  }
-
-  destroy() {
-    // @ts-ignore
-    delete this.raw; // @ts-ignore
-
-    delete this.response;
-  }
-  /**
-   * Return the Framework response object (express, koa, etc...)
-   */
-
-
-  getRequest() {
-    return this.raw;
-  }
-  /**
-   * Return the Node.js response object
-   */
-
-
-  getReq() {
-    return this.raw;
-  }
-
-};
-exports.PlatformRequest = tslib.__decorate([di.Injectable(), di.Scope(di.ProviderScope.INSTANCE), tslib.__metadata("design:paramtypes", [Object])], exports.PlatformRequest);
-
-var PlatformResponse_1;
-
-const onFinished = require("on-finished");
-/**
- * Platform Response abstraction layer.
- * @platform
- */
-
-
-exports.PlatformResponse = PlatformResponse_1 = class PlatformResponse {
-  constructor({
-    response
-  }) {
-    this.raw = response;
-  }
-  /**
-   * Get the current statusCode
-   */
-
-
-  get statusCode() {
-    return this.raw.statusCode;
-  }
-  /**
-   * An object that contains response local variables scoped to the request, and therefore available only to the view(s) rendered during that request / response cycle (if any). Otherwise, this property is identical to app.locals.
-   *
-   * This property is useful for exposing request-level information such as the request path name, authenticated user, user settings, and so on.
-   */
-
-
-  get locals() {
-    return this.raw.locals;
-  }
-  /**
-   * Return the original response framework instance
-   */
-
-
-  get response() {
-    return this.getResponse();
-  }
-  /**
-   * Return the original response node.js instance
-   */
-
-
-  get res() {
-    return this.getRes();
-  }
-
-  static onFinished(res, cb) {
-    onFinished(res, cb);
-  }
-  /**
-   * Returns the HTTP response header specified by field. The match is case-insensitive.
-   *
-   * ```typescript
-   * response.get('Content-Type') // => "text/plain"
-   * ```
-   *
-   * @param name
-   */
-
-
-  get(name) {
-    return this.raw.get(name);
-  }
-
-  getHeaders() {
-    return this.raw.getHeaders();
-  }
-  /**
-   * Return the Framework response object (express, koa, etc...)
-   */
-
-
-  getResponse() {
-    return this.raw;
-  }
-  /**
-   * Return the Node.js response object
-   */
-
-
-  getRes() {
-    return this.raw;
-  }
-
-  hasStatus() {
-    return this.statusCode !== 200;
-  }
-  /**
-   * Sets the HTTP status for the response.
-   *
-   * @param status
-   */
-
-
-  status(status) {
-    this.raw.status(status);
-    return this;
-  }
-  /**
-   * Set header `field` to `val`, or pass
-   * an object of header fields.
-   *
-   * Examples:
-   * ```typescript
-   * response.setHeaders({ Accept: 'text/plain', 'X-API-Key': 'tobi' });
-   * ```
-   *
-   * Aliased as `res.header()`.
-   */
-
-
-  setHeaders(headers) {
-    // apply headers
-    Object.entries(headers).forEach(([key, item]) => {
-      this.setHeader(key, item);
-    });
-    return this;
-  }
-
-  setHeader(key, item) {
-    if (key.toLowerCase() === "location") {
-      return this.location(String(item));
-    }
-
-    this.raw.set(key, item);
-    return this;
-  }
-  /**
-   * Set `Content-Type` response header with `type` through `mime.lookup()`
-   * when it does not contain "/", or set the Content-Type to `type` otherwise.
-   *
-   * Examples:
-   *
-   *     res.type('.html');
-   *     res.type('html');
-   *     res.type('json');
-   *     res.type('application/json');
-   *     res.type('png');
-   */
-
-
-  contentType(contentType) {
-    this.raw.contentType(contentType);
-    return this;
-  }
-
-  contentLength(length) {
-    this.setHeader("Content-Length", length);
-    return this;
-  }
-
-  getContentLength() {
-    if (this.get("Content-Length")) {
-      return parseInt(this.get("Content-Length"), 10) || 0;
-    }
-  }
-
-  getContentType() {
-    return (this.get("Content-Type") || "").split(";")[0];
-  }
-  /**
-   * Sets the HTTP response Content-Disposition header field to “attachment”.
-   * If a filename is given, then it sets the Content-Type based on the extension name via res.type(), and sets the Content-Disposition “filename=” parameter.
-   *
-   * ```typescript
-   * res.attachment()
-   * // Content-Disposition: attachment
-   *
-   * res.attachment('path/to/logo.png')
-   * // Content-Disposition: attachment; filename="logo.png"
-   * // Content-Type: image/png
-   * ```
-   *
-   * @param filename
-   */
-
-
-  attachment(filename) {
-    this.raw.attachment(filename);
-    return this;
-  }
-  /**
-   * Redirects to the URL derived from the specified path, with specified status, a positive integer that corresponds to an [HTTP status code](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html).
-   * If not specified, status defaults to `302 Found`.
-   *
-   * @param status
-   * @param url
-   */
-
-
-  redirect(status, url) {
-    this.raw.redirect(status, url);
-    return this;
-  }
-  /**
-   * Sets the response Location HTTP header to the specified path parameter.
-   *
-   * @param location
-   */
-
-
-  location(location) {
-    this.raw.location(location);
-    return this;
-  }
-  /**
-   * Stream the given data.
-   *
-   * @param data
-   */
-
-
-  stream(data) {
-    data.pipe(this.raw);
-    return this;
-  }
-  /**
-   * Renders a view and sends the rendered HTML string to the client.
-   *
-   * @param path
-   * @param options
-   */
-
-
-  async render(path, options = {}) {
-    return this.platformViews.render(path, _extends({}, this.locals, options));
-  }
-  /**
-   * Send any data to your consumer.
-   *
-   * This method accept a ReadableStream, a plain object, boolean, string, number, null and undefined data.
-   * It choose the better way to send the data.
-   *
-   * @param data
-   */
-
-
-  body(data) {
-    this.data = data;
-
-    if (data === undefined) {
-      this.raw.send();
-      return this;
-    }
-
-    if (core.isStream(data)) {
-      this.stream(data);
-      return this;
-    }
-
-    if (Buffer.isBuffer(data)) {
-      if (!this.getContentType()) {
-        this.contentType("application/octet-stream");
-      }
-
-      this.contentLength(data.length);
-      this.raw.send(data);
-      return this;
-    }
-
-    if (core.isBoolean(data) || core.isNumber(data) || core.isString(data) || data === null) {
-      this.raw.send(data);
-      return this;
-    }
-
-    this.raw.json(data);
-    return this;
-  }
-
-  getBody() {
-    return this.data;
-  }
-  /**
-   * Add a listener to handler the end of the request/response.
-   * @param cb
-   */
-
-
-  onEnd(cb) {
-    PlatformResponse_1.onFinished(this.getRes(), cb);
-    return this;
-  }
-
-  isDone() {
-    if (!this.raw) {
-      return true;
-    }
-
-    const res = this.getRes();
-    return Boolean(this.isHeadersSent() || res.writableEnded || res.writableFinished);
-  }
-
-  destroy() {
-    // @ts-ignore
-    delete this.raw;
-    delete this.data; // @ts-ignore
-
-    delete this.request;
-  }
-
-  isHeadersSent() {
-    return this.getRes().headersSent;
-  }
-
-};
-exports.PlatformResponse = PlatformResponse_1 = tslib.__decorate([di.Injectable(), di.Scope(di.ProviderScope.INSTANCE), tslib.__metadata("design:paramtypes", [Object])], exports.PlatformResponse);
-
-const _excluded$2 = ["event", "endpoint", "ignoreUrlPatterns", "ResponseKlass", "RequestKlass"];
-class PlatformContext extends di.DIContext {
-  constructor(_ref) {
-    let {
-      event,
-      endpoint,
-      ignoreUrlPatterns = [],
-      ResponseKlass = exports.PlatformResponse,
-      RequestKlass = exports.PlatformRequest
-    } = _ref,
-        options = _objectWithoutPropertiesLoose(_ref, _excluded$2);
-
-    super(_extends({}, options, {
-      ignoreLog: () => {
-        return this.ignoreUrlPatterns.find(reg => !!this.url.match(reg));
-      }
-    }));
-    this.ignoreUrlPatterns = [];
-    endpoint && (this.endpoint = endpoint);
-    this.ignoreUrlPatterns = ignoreUrlPatterns.map(pattern => typeof pattern === "string" ? new RegExp(pattern, "gi") : pattern);
-    this.response = new ResponseKlass(event);
-    this.request = new RequestKlass(event);
-    this.response.request = this.request;
-    this.request.response = this.response;
-    this.request.request.$ctx = this;
-    this.request.request.id = this.id;
-    this.logger.url = this.url;
-    this.container.set(exports.PlatformResponse, this.response);
-    this.container.set(exports.PlatformRequest, this.request);
-    this.container.set(PlatformContext, this);
-    this.response.setHeader("x-request-id", this.id);
-  }
-
-  get url() {
-    return this.request.url;
-  }
-
-  get app() {
-    return this.injector.get(exports.PlatformApplication);
-  }
-
-  async destroy() {
-    var _this$request, _this$request$request;
-
-    await super.destroy();
-    (_this$request = this.request) == null ? true : (_this$request$request = _this$request.request) == null ? true : delete _this$request$request.$ctx;
-    this.response.destroy();
-    this.request.destroy(); // @ts-ignore
-
-    delete this.endpoint; // @ts-ignore
-
-    delete this.response; // @ts-ignore
-
-    delete this.request;
-  }
-
-  isDone() {
-    return !this.request || !this.response;
-  }
-  /**
-   * Return the framework request instance (Express, Koa, etc...)
-   */
-
-
-  getRequest() {
-    return this.request.getRequest();
-  }
-  /**
-   * Return the framework response instance (Express, Koa, etc...)
-   */
-
-
-  getResponse() {
-    return this.response.getResponse();
-  }
-  /**
-   * Get Node.js request
-   */
-
-
-  getReq() {
-    return this.request.getReq();
-  }
-  /**
-   * Get Node.js response
-   */
-
-
-  getRes() {
-    return this.response.getRes();
-  }
-  /**
-   * Return the original application instance.
-   */
-
-
-  getApp() {
-    return this.app.getApp();
-  }
-
-}
-
-class PlatformRouteDetails extends schema.JsonOperationRoute {
-  constructor(options = {}) {
-    super(options);
-    this.rawBody = !!this.endpoint.parameters.find(param => param.paramType === platformParams.ParamTypes.RAW_BODY);
-  }
-
-  toJSON() {
-    return {
-      method: this.method,
-      name: this.name,
-      url: this.url,
-      className: this.className,
-      methodClassName: this.methodClassName,
-      parameters: this.parameters,
-      rawBody: this.rawBody
-    };
-  }
-
-}
-
-/**
- * @deprecated Since 2020-11-11. Use getProperties from @tsed/schema
- */
-
-exports.PropertyMetadata = class PropertyMetadata extends schema.JsonPropertyStore {
-  /**
-   * @deprecated Since 2020-11-11. Use getProperties from @tsed/schema
-   */
-  static get(target, propertyKey) {
-    return schema.JsonEntityStore.from(core.prototypeOf(target), propertyKey);
-  }
-  /**
-   * @deprecated Since 2020-11-11. Use getProperties from @tsed/schema
-   */
-
-
-  static getProperties(target, options = {}) {
-    return schema.getProperties(target, options);
-  }
-
-};
-exports.PropertyMetadata = tslib.__decorate([schema.JsonEntityComponent(core.DecoratorTypes.PROP)], exports.PropertyMetadata);
-
-/**
- * `Platform` is used to provide all routes collected by annotation `@Controller`.
- *
- * @platform
- */
-
-exports.Platform = class Platform {
-  constructor(injector, platformApplication) {
-    this.injector = injector;
-    this.platformApplication = platformApplication;
-    this._routes = [];
-    this._controllers = [];
-    this.createRouters();
-  }
-
-  get app() {
-    return this.platformApplication;
-  }
-
-  get routes() {
-    return this._routes;
-  }
-
-  addRoutes(routes) {
-    routes.forEach(routeSettings => {
-      this.addRoute(routeSettings.route, routeSettings.token);
-    });
-  }
-
-  addRoute(basePath, token) {
-    const {
-      injector
-    } = this;
-    const provider = injector.getProvider(token);
-
-    if (!provider || provider.hasParent()) {
-      return;
-    }
-
-    const ctrlPath = schema.concatPath(basePath, schema.JsonEntityStore.from(provider.token).path);
-
-    this._controllers.push({
-      route: ctrlPath,
-      provider
-    });
-
-    this.app.use(ctrlPath, ...[].concat(getRouter(injector, provider).callback()));
-    this._routes = schema.getOperationsRoutes(provider.token, {
-      withChildren: true,
-      basePath
-    }).reduce((routes, operationRoute) => {
-      if (injector.hasProvider(token)) {
-        const provider = injector.getProvider(operationRoute.token);
-        const route = new PlatformRouteDetails(_extends({}, operationRoute, {
-          provider
-        }));
-        return routes.concat(route);
-      }
-
-      return routes;
-    }, this._routes);
-    return this;
-  }
-  /**
-   * Get all routes built by TsExpressDecorators and mounted on Express application.
-   * @returns {PlatformRouteDetails[]}
-   */
-
-
-  getRoutes() {
-    return this._routes;
-  }
-
-  getMountedControllers() {
-    return this._controllers;
-  }
-
-  $onInit() {
-    this.buildControllers();
-  }
-  /**
-   * Create routers from the collected controllers.
-   * @private
-   */
-
-
-  createRouters() {
-    const {
-      injector
-    } = this;
-    injector.getProviders(di.ProviderType.CONTROLLER).map(provider => {
-      createRouter(injector, provider);
-    });
-  }
-  /**
-   * Create controllers from DI
-   * @private
-   */
-
-
-  buildControllers() {
-    const {
-      injector
-    } = this;
-    injector.getProviders(di.ProviderType.CONTROLLER).map(provider => {
-      if (!provider.hasParent()) {
-        return buildRouter(injector, provider);
-      }
-    });
-  }
-
-};
-exports.Platform = tslib.__decorate([di.Injectable({
-  scope: di.ProviderScope.SINGLETON,
-  imports: [exports.PlatformMiddlewaresChain]
-}), tslib.__metadata("design:paramtypes", [di.InjectorService, exports.PlatformApplication])], exports.Platform);
-
-logger.$log.name = "TSED";
-function createInjector(settings = {}) {
-  const injector = new di.InjectorService();
-  injector.addProvider(exports.PlatformConfiguration);
-  injector.settings = injector.invoke(exports.PlatformConfiguration);
-  injector.logger = logger.$log;
-  injector.settings.set(settings);
-  di.setLoggerLevel(injector);
-  return injector;
-}
-
-function createPlatformApplication(injector) {
-  injector.forkProvider(exports.PlatformApplication);
-}
-
-/**
- * Inject the Http.Server instance.
- *
- * ### Example
- *
- * ```typescript
- * import {HttpServer, Service} from "@tsed/common";
- *
- * @Service()
- * export default class OtherService {
- *    constructor(@HttpServer httpServer: HttpServer) {}
- * }
- * ```
- *
- * > Note: TypeScript transform and store `HttpServer` as `Function` type in the metadata. So to inject a factory, you must use the `@Inject(type)` decorator.
- *
- * @param {Type<any>} target
- * @param {string} targetKey
- * @param {TypedPropertyDescriptor<Function> | number} descriptor
- * @returns {any}
- * @decorator
- */
-
-function HttpServer(target, targetKey, descriptor) {
-  return di.Inject(HttpServer)(target, targetKey, descriptor);
-}
-
-function listenServer(http, settings) {
-  const {
-    address,
-    port
-  } = settings;
-  const promise = new Promise((resolve, reject) => {
-    http.on("listening", resolve);
-    http.on("error", reject);
-  }).then(() => {
-    const port = http.address().port;
-    return {
-      address: settings.address,
-      port
-    };
-  });
-  http.listen(port, address);
-  return promise;
-}
-
-function createHttpServer(injector) {
-  injector.forkProvider(HttpServer);
-}
-di.registerProvider({
-  provide: HttpServer,
-  deps: [exports.PlatformApplication],
-  scope: di.ProviderScope.SINGLETON,
-  global: true,
-
-  useFactory(platformApplication) {
-    return Http__default['default'].createServer(platformApplication.callback());
-  }
-
-});
-async function listenHttpServer(injector) {
-  const {
-    settings
-  } = injector;
-  const server = injector.get(HttpServer);
-
-  if (settings.httpPort !== false && server) {
-    const {
-      address,
-      port
-    } = settings.getHttpPort();
-    injector.logger.debug(`Start server on http://${address}:${port}`);
-    const options = await listenServer(server, {
-      address,
-      port
-    });
-    settings.setHttpPort(options);
-    injector.logger.info(`Listen server on http://${options.address}:${options.port}`);
-  }
-}
-
-/**
- * Inject the Https.Server instance.
- *
- * ### Example
- *
- * ```typescript
- * import {HttpsServer, Service} from "@tsed/common";
- *
- * @Service()
- * export default class OtherService {
- *    constructor(@HttpsServer httpServer: HttpServer) {}
- * }
- * ```
- *
- * > Note: TypeScript transform and store `HttpsServer` as `Function` type in the metadata. So to inject a factory, you must use the `@Inject(type)` decorator.
- *
- * @param {Type<any>} target
- * @param {string} targetKey
- * @param {TypedPropertyDescriptor<Function> | number} descriptor
- * @returns {any}
- * @decorator
- */
-
-function HttpsServer(target, targetKey, descriptor) {
-  return di.Inject(HttpsServer)(target, targetKey, descriptor);
-}
-
-function createHttpsServer(injector) {
-  injector.forkProvider(HttpsServer);
-}
-di.registerProvider({
-  provide: HttpsServer,
-  deps: [exports.PlatformApplication, di.Configuration],
-  scope: di.ProviderScope.SINGLETON,
-  global: true,
-
-  useFactory(platformApplication, settings) {
-    const options = settings.httpsOptions;
-    return Https__default['default'].createServer(options, platformApplication.callback());
-  }
-
-});
-async function listenHttpsServer(injector) {
-  const {
-    settings
-  } = injector;
-  const server = injector.get(HttpsServer);
-
-  if (settings.httpsPort !== false && server) {
-    const {
-      address,
-      port
-    } = settings.getHttpsPort();
-    injector.logger.debug(`Start server on https://${address}:${port}`);
-    const options = await listenServer(server, {
-      address,
-      port
-    });
-    settings.setHttpsPort(options);
-    injector.logger.info(`Listen server on https://${options.address}:${options.port}`);
-  }
-}
-
-/**
- * @ignore
- * @deprecated User injector.load(container, module) instead
- */
-
-async function loadInjector(injector, container = di.createContainer()) {
-  injector.bootstrap(container);
-  return injector.load(container);
-}
-
-function printRoutes(routes) {
-  const mapColor = {
-    GET: "green",
-    POST: "yellow",
-    PUT: "blue",
-    DELETE: "red",
-    PATCH: "magenta",
-    ALL: "cyan"
-  };
-  const list = routes.map(route => {
-    const obj = route.toJSON();
-    const method = obj.method.toUpperCase();
-    obj.method = {
-      length: method.length,
-      toString: () => {
-        return logger.colorize(method, mapColor[method]);
-      }
-    };
-    return obj;
-  });
-  const str = logger.$log.drawTable(list, {
-    padding: 1,
-    header: {
-      method: "Method",
-      url: "Endpoint",
-      name: "Class method"
-    }
-  });
-  return "\n" + str.trim();
-}
-
-const _excluded$1 = ["reqIdBuilder"];
-
-const uuidv4 = require("uuid").v4;
-
-const defaultReqIdBuilder = req => req.get("x-request-id") || uuidv4().replace(/-/gi, "");
-/**
- * Create the TsED context to wrap request, response, injector, etc...
- * @param injector
- * @ignore
- */
-
-
-function createContext(injector) {
-  var _injector$getProvider, _injector$getProvider2;
-
-  const ResponseKlass = (_injector$getProvider = injector.getProvider(exports.PlatformResponse)) == null ? void 0 : _injector$getProvider.useClass;
-  const RequestKlass = (_injector$getProvider2 = injector.getProvider(exports.PlatformRequest)) == null ? void 0 : _injector$getProvider2.useClass;
-  const platformViews$1 = injector.get(platformViews.PlatformViews);
-
-  const _ref = injector.settings.logger || {},
-        {
-    reqIdBuilder = defaultReqIdBuilder
-  } = _ref,
-        loggerOptions = _objectWithoutPropertiesLoose(_ref, _excluded$1);
-
-  return async event => {
-    const ctx = new PlatformContext(_extends({
-      event,
-      id: reqIdBuilder(event.request),
-      logger: injector.logger
-    }, loggerOptions, {
-      injector,
-      ResponseKlass,
-      RequestKlass
-    }));
-    ctx.response.platformViews = platformViews$1;
-    ctx.response.onEnd(async () => {
-      await ctx.emit("$onResponse", ctx);
-      await ctx.destroy();
-    });
-    await ctx.emit("$onRequest", ctx);
-    return ctx;
-  };
-}
-
-function mapOptions$1(options) {
-  const opts = typeof options === "string" ? {
-    root: options
-  } : options;
-  return _extends({}, opts, {
-    hook: core.getValue(opts, "hook", "$afterRoutesInit")
-  });
-}
-
-function getStaticsOptions(statics) {
-  return Object.entries(statics || {}).reduce((statics, [path, items]) => {
-    [].concat(items).forEach(options => {
-      statics.push({
-        path,
-        options: mapOptions$1(options)
-      });
-    });
-    return statics;
-  }, []);
-}
-
-function getConfiguration(configuration = {}, module = null) {
-  const store = module ? core.Store.from(module).get("configuration") || {} : {};
-  const env = configuration.env || store.mount || process.env.NODE_ENV || core.Env.DEV;
-
-  const config = _extends({
-    exclude: ["**/*.spec.ts", "**/*.spec.js"],
-    componentsScan: ["${rootDir}/mvc/**/*.ts", "${rootDir}/services/**/*.ts", "${rootDir}/middlewares/**/*.ts"],
-    env,
-    httpPort: 8080,
-    httpsPort: false
-  }, store, configuration, {
-    scopes: _extends({
-      [di.ProviderType.CONTROLLER]: di.ProviderScope.SINGLETON
-    }, store.scopes, configuration.scopes),
-    mount: store.mount || configuration.mount ? core.deepMerge(store.mount || {}, configuration.mount || {}) : {
-      "/rest": "${rootDir}/controllers/**/*.ts"
-    },
-    logger: _extends({
-      debug: false,
-      level: env === core.Env.TEST ? "off" : "info",
-      logRequest: true
-    }, store.logger, configuration.logger, {
-      jsonIndentation: process.env.NODE_ENV === core.Env.PROD ? 0 : 2
-    })
-  });
-
-  if (!configuration.disableComponentsScan && store.componentsScan && configuration.componentsScan) {
-    config.componentsScan = [...store.componentsScan, ...configuration.componentsScan];
-  }
-
-  return config;
-}
-
-const DEFAULT_PROVIDERS = [{
-  provide: exports.PlatformHandler
-}, {
-  provide: exports.PlatformResponse
-}, {
-  provide: exports.PlatformRequest
-}, {
-  provide: exports.PlatformRouter
-}, {
-  provide: exports.PlatformApplication
-}, {
-  provide: exports.Platform
-}];
-/**
- * @platform
- */
-
-var _injector = /*#__PURE__*/_classPrivateFieldLooseKey("injector");
-
-var _rootModule = /*#__PURE__*/_classPrivateFieldLooseKey("rootModule");
-
-class PlatformBuilder {
-  constructor({
-    name,
-    providers,
-    settings,
-    module
-  }) {
-    Object.defineProperty(this, _injector, {
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, _rootModule, {
-      writable: true,
-      value: void 0
-    });
-    this.name = "";
-    this.startedAt = new Date();
-    this.current = new Date();
-    this.name = name;
-    _classPrivateFieldLooseBase(this, _rootModule)[_rootModule] = module;
-    this.createInjector(module, providers, settings);
-  }
-
-  get injector() {
-    return _classPrivateFieldLooseBase(this, _injector)[_injector];
-  }
-
-  get rootModule() {
-    return _classPrivateFieldLooseBase(this, _injector)[_injector].get(_classPrivateFieldLooseBase(this, _rootModule)[_rootModule]);
-  }
-
-  get app() {
-    return this.injector.get(exports.PlatformApplication);
-  }
-
-  get platform() {
-    return this.injector.get(exports.Platform);
-  }
-  /**
-   * Return the settings configured by the decorator @@Configuration@@.
-   *
-   * ```typescript
-   * @Configuration({
-   *    rootDir: Path.resolve(__dirname),
-   *    port: 8000,
-   *    httpsPort: 8080,
-   *    mount: {
-   *      "/rest": "${rootDir}/controllers/**\/*.js"
-   *    }
-   * })
-   * export class Server {
-   *     $onInit(){
-   *         console.log(this.settings); // {rootDir, port, httpsPort,...}
-   *     }
-   * }
-   * ```
-   *
-   * @returns {PlatformConfiguration}
-   */
-
-
-  get settings() {
-    return this.injector.settings;
-  }
-
-  get logger() {
-    return this.injector.logger;
-  }
-
-  get disableBootstrapLog() {
-    var _this$settings$logger;
-
-    return (_this$settings$logger = this.settings.logger) == null ? void 0 : _this$settings$logger.disableBootstrapLog;
-  }
-
-  static build(platformBuildClass, module, settings = {}) {
-    return new platformBuildClass({
-      name: core.nameOf(platformBuildClass).replace("Platform", "").toLowerCase(),
-      module,
-      settings,
-      providers: platformBuildClass.providers
-    });
-  }
-
-  callback(req, res) {
-    if (req && res) {
-      return this.app.callback()(req, res);
-    }
-
-    return this.app.callback();
-  }
-
-  log(...data) {
-    return !this.disableBootstrapLog && this.logger.info(...data, this.diff());
-  }
-  /**
-   * Add classes to the components list
-   * @param classes
-   */
-
-
-  addComponents(classes) {
-    this.settings.componentsScan = this.settings.componentsScan.concat(classes);
-    return this;
-  }
-  /**
-   * Add classes decorated by @@Controller@@ to components container.
-   *
-   * ### Example
-   *
-   * ```typescript
-   * @Controller('/ctrl')
-   * class MyController{
-   * }
-   *
-   * platform.addControllers('/rest', [MyController])
-   * ```
-   *
-   * ::: tip
-   * If the MyController class isn't decorated, the class will be ignored.
-   * :::
-   *
-   * @param {string} endpoint
-   * @param {any[]} controllers
-   */
-
-
-  addControllers(endpoint, controllers) {
-    this.settings.mount[endpoint] = (this.settings.mount[endpoint] || []).concat(controllers);
-  }
-
-  async runLifecycle() {
-    di.setLoggerLevel(this.injector);
-    await this.importProviders();
-    await this.loadInjector();
-    this.useContext();
-    this.useRouter();
-    await this.loadRoutes();
-    await this.logRoutes();
-    return this;
-  }
-
-  async loadInjector() {
-    const {
-      injector
-    } = this;
-    this.log("Build providers");
-    const container = di.createContainer();
-    container.addProvider(_classPrivateFieldLooseBase(this, _rootModule)[_rootModule], {
-      type: "server:module",
-      scope: di.ProviderScope.SINGLETON
-    });
-    await injector.load(container);
-    this.log("Settings and injector loaded...");
-    await this.callHook("$afterInit");
-  }
-
-  async listen() {
-    await this.callHook("$beforeListen");
-    await this.listenServers();
-    await this.callHook("$afterListen");
-    await this.ready();
-  }
-
-  async stop() {
-    await this.callHook("$onDestroy");
-    return this.injector.destroy();
-  }
-
-  async ready() {
-    const {
-      startedAt
-    } = this;
-    await this.callHook("$onReady");
-    await this.injector.emit("$onServerReady");
-    this.log(`Started in ${new Date().getTime() - startedAt.getTime()} ms`);
-  }
-
-  async callHook(hook, ...args) {
-    const {
-      injector
-    } = this;
-
-    if (!this.disableBootstrapLog) {
-      injector.logger.debug(`\x1B[1mCall hook ${hook}\x1B[22m`);
-    } // Load middlewares for the given hook
-
-
-    this.loadMiddlewaresFor(hook); // call hooks added by providers
-
-    await injector.emit(hook, ...args);
-  }
-
-  async loadStatics(hook) {
-    const statics = this.settings.get("statics");
-    getStaticsOptions(statics).forEach(({
-      path,
-      options
-    }) => {
-      if (options.hook === hook) {
-        this.platform.app.statics(path, options);
-      }
-    });
-  }
-
-  useProvider(token, settings) {
-    this.injector.addProvider(token, settings);
-    return this;
-  }
-
-  async bootstrap() {
-    return this.runLifecycle();
-  }
-
-  diff() {
-    const ms = di.colors.yellow(`+${new Date().getTime() - this.current.getTime()}ms`);
-    this.current = new Date();
-    return ms;
-  }
-
-  async importProviders() {
-    this.injector.logger.debug("Scan components");
-    const providers = await componentsScan.importProviders(this.injector.settings, ["imports", "mount", "componentsScan"]);
-    const routes = providers.filter(provider => !!provider.route).map(({
-      route,
-      token
-    }) => ({
-      route,
-      token
-    }));
-    this.settings.set("routes", routes);
-    this.log("Providers loaded...");
-  }
-  /**
-   * Load middlewares from configuration for the given hook
-   * @param hook
-   * @protected
-   */
-
-
-  loadMiddlewaresFor(hook) {
-    return platformMiddlewares.getMiddlewaresForHook(hook, this.settings, "$beforeRoutesInit").forEach(({
-      use
-    }) => {
-      this.app.use(use);
-    });
-  }
-
-  useRouter() {
-    return this;
-  }
-
-  useContext() {
-    return this;
-  }
-
-  async listenServers() {
-    await Promise.all([listenHttpServer(this.injector), listenHttpsServer(this.injector)]);
-  }
-
-  async logRoutes() {
-    var _this$settings$logger2;
-
-    const {
-      logger,
-      platform
-    } = this;
-    this.log("Routes mounted...");
-
-    if (!((_this$settings$logger2 = this.settings.logger) != null && _this$settings$logger2.disableRoutesSummary) && !this.disableBootstrapLog) {
-      logger.info(printRoutes(await this.injector.alterAsync("$logRoutes", platform.getRoutes())));
-    }
-  }
-
-  async loadRoutes() {
-    var _this$settings$logger3, _this$settings$accept;
-
-    // istanbul ignore next
-    if (((_this$settings$logger3 = this.settings.logger) == null ? void 0 : _this$settings$logger3.level) !== "off") {
-      const {
-        PlatformLogMiddleware
-      } = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('@tsed/platform-log-middleware')); });
-      this.app.use(PlatformLogMiddleware);
-    }
-
-    if ((_this$settings$accept = this.settings.acceptMimes) != null && _this$settings$accept.length) {
-      this.app.use(exports.GlobalAcceptMimesMiddleware);
-    }
-
-    this.log("Load routes");
-    await this.loadStatics("$beforeRoutesInit");
-    await this.callHook("$beforeRoutesInit");
-    const routes = this.injector.settings.get("routes");
-    this.platform.addRoutes(routes);
-    await this.callHook("$onRoutesInit");
-    await this.loadStatics("$afterRoutesInit");
-    await this.callHook("$afterRoutesInit");
-  }
-
-  createInjector(module, providers, settings) {
-    const configuration = getConfiguration(settings, module);
-    configuration.PLATFORM_NAME = this.name;
-    _classPrivateFieldLooseBase(this, _injector)[_injector] = createInjector(configuration);
-    providers = [...DEFAULT_PROVIDERS, ...providers];
-    core.toMap(providers, "provide").forEach((provider, token) => {
-      this.injector.addProvider(token, provider);
-    });
-    createPlatformApplication(this.injector);
-    createHttpsServer(this.injector);
-    createHttpServer(this.injector);
-    this.log("Injector created...");
-  }
-
-}
-
-/**
- * Define multer option for all MultipartFile
- *
- * ```typescript
- * import {Controller, Post, PlatformMulterFile, MultipartFile, MulterOptions} from "@tsed/common";
- *
- * @Controller('/')
- * class MyCtrl {
- *   @Post('/file')
- *   private uploadFile(@MultipartFile("file1") file: PlatformMulterFile) {
- *
- *   }
- *
- *   @Post('/file')
- *   @MulterOptions({dest: "/other-dir"})
- *   private uploadFile(@MultipartFile("file1") file: PlatformMulterFile) {
- *
- *   }
- *
- *   @Post('/file2')
- *   @MulterOptions({dest: "/other-dir"})
- *   private uploadFile(@MultipartFile("file1") file: PlatformMulterFile, @MultipartFile("file2") file2: PlatformMulterFile) {
- *
- *   }
- *
- *   @Post('/files')
- *   private uploadFile(@MultipartFile("file1") files: PlatformMulterFile[]) {
- *
- *   }
- * }
- * ```
- *
- * See the tutorial on the [multer configuration](/tutorials/multer.md).
- *
- * @param {multer.Options} options
- * @returns {(target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor}
- * @decorator
- * @multer
- */
-
-function MulterOptions(options) {
-  return (target, propertyKey, descriptor) => {
-    core.StoreMerge(exports.PlatformMulterMiddleware, {
-      options
-    })(target, propertyKey, descriptor);
-    return descriptor;
-  };
-}
-
-/**
- * Define file size limit.
- *
- * ```typescript
- * import {Controller, Post} from "@tsed/common";
- * import {MulterOptions, MultipartFile} from "@tsed/common";
- * import {Multer} from "@types/multer";
- *
- * type MulterFile = Express.Multer.File;
- *
- * @Controller('/')
- * class MyCtrl {
- *   @Post('/file2')
- *   @MulterFileSize(1024) // (Ko). Applied for all fields
- *   private uploadFile(@MultipartFile("file1") file: MulterFile, @MultipartFile("file2") file2: MulterFile) {
- *
- *   }
- * }
- * ```
- *
- * > See the tutorial on the [multer configuration](/tutorials/multer.md).
- * @param fileSize
- * @returns {(target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor}
- * @decorator
- * @multer
- */
-
-function MulterFileSize(fileSize) {
-  return MulterOptions({
-    limits: {
-      fileSize
-    }
-  });
-}
-
-function mapOptions(name, maxCount) {
-  return {
-    fields: [{
-      name,
-      maxCount
-    }]
-  };
-}
-/**
- * Define a parameter as Multipart file.
- *
- * ```typescript
- * import {Controller, Post} from "@tsed/common";
- * import {MulterOptions, MultipartFile} from "@tsed/common";
- * import {Multer} from "@types/multer";
- *
- * type MulterFile = Express.Multer.File;
- *
- * @Controller('/')
- * class MyCtrl {
- *   @Post('/file')
- *   private uploadFile(@MultipartFile("file1") file: MulterFile) {
- *
- *   }
- *
- *   @Post('/file')
- *   @MulterOptions({dest: "/other-dir"})
- *   private uploadFile(@MultipartFile("file1") file: MulterFile) {
- *
- *   }
- *
- *   @Post('/file2')
- *   @MulterOptions({dest: "/other-dir"})
- *   private uploadFile(@MultipartFile("file1") file: MulterFile, @MultipartFile("file2") file2: MulterFile) {
- *
- *   }
- *
- *   @Post('/files')
- *   private uploadFile(@MultipartFile("file1") files: MulterFile[]) {
- *
- *   }
- * }
- * ```
- *
- * > See the tutorial on the [multer configuration](/tutorials/multer.md).
- *
- * @param name
- * @param maxCount
- * @returns Function
- * @decorator
- * @input
- */
-
-
-function MultipartFile(name, maxCount) {
-  return (...args) => {
-    const [target, propertyKey, index] = args;
-    const multiple = core.Metadata.getParamTypes(target, propertyKey)[index] === Array;
-    name = typeof name === "object" ? undefined : name;
-    const expression = [name, !multiple && "0"].filter(Boolean).join(".");
-    const decorators = core.useDecorators(core.useMethodDecorators(schema.Returns(400).Description(`<File too long | Too many parts | Too many files | Field name too long | Field value too long | Too many fields | Unexpected field>  [fieldName] Example: File too long file1`), schema.Consumes("multipart/form-data"), core.StoreMerge(exports.PlatformMulterMiddleware, mapOptions(name, maxCount))), platformParams.UseParam({
-      paramType: platformParams.ParamTypes.FILES,
-      dataPath: "$ctx.request.files",
-      expression,
-      useValidation: true
-    }));
-    decorators(...args);
-  };
-}
-
-/**
- * Set a mime list which are acceptable and checks if the specified content types are acceptable, based on the request’s Accept HTTP header field.
- *
- * ```typescript
- *  @Controller('/mypath')
- *  export class MyCtrl {
- *
- *    @Get('/')
- *    @AcceptMime('application/json')
- *    public getResource(){}
- *  }
- * ```
- *
- * @param mimes
- * @decorator
- * @operation
- * @response
- */
-
-function AcceptMime(...mimes) {
-  return core.useDecorators(schema.Produces(...mimes), core.StoreSet("acceptMimes", mimes));
-}
-
-/**
- *
- * @param fn
- * @decorator
- * @deprecated Deprecated since 2021-10-05. Use JsonEntityFn instead.
- */
-
-function EndpointFn(fn) {
-  return schema.JsonEntityFn(fn);
-}
-
-/**
- * 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.
- */
-
-function ResponseData() {
-  return platformParams.UseParam({
-    paramType: platformParams.ParamTypes.$CTX,
-    dataPath: "$ctx.data"
-  });
-}
-
-function getParamType$1(target, propertyKey, parameterIndex) {
-  const type = core.Metadata.getOwnParamTypes(target, propertyKey)[parameterIndex];
-
-  if (core.isClass(type)) {
-    if (core.nameOf(type) === "PlatformResponse") {
-      return {
-        paramType: platformParams.ParamTypes.PLATFORM_RESPONSE,
-        dataPath: "$ctx.response"
-      };
-    }
-
-    if (type === Http.ServerResponse) {
-      return {
-        paramType: platformParams.ParamTypes.NODE_RESPONSE,
-        dataPath: "$ctx.response.res"
-      };
-    }
-  }
-
-  return {
-    paramType: platformParams.ParamTypes.RESPONSE,
-    dataPath: "$ctx.response.response"
-  };
-}
-
-function Response() {
-  return Res();
-}
-function Res() {
-  return (target, propertyKey, parameterIndex) => {
-    const {
-      paramType,
-      dataPath
-    } = getParamType$1(target, propertyKey, parameterIndex);
-    platformParams.UseParam({
-      paramType,
-      dataPath
-    })(target, propertyKey, parameterIndex);
-  };
-}
-
-function getParamType(target, propertyKey, parameterIndex) {
-  const type = core.Metadata.getOwnParamTypes(target, propertyKey)[parameterIndex];
-
-  if (core.isClass(type)) {
-    if (core.nameOf(type) === "PlatformRequest") {
-      return {
-        paramType: platformParams.ParamTypes.PLATFORM_REQUEST,
-        dataPath: "$ctx.request"
-      };
-    }
-
-    if (type === Http.IncomingMessage) {
-      return {
-        paramType: platformParams.ParamTypes.NODE_REQUEST,
-        dataPath: "$ctx.request.req"
-      };
-    }
-  }
-
-  return {
-    paramType: platformParams.ParamTypes.REQUEST,
-    dataPath: "$ctx.request.request"
-  };
-}
-
-function Request(...args) {
-  // @ts-ignore
-  return Req(...args);
-}
-function Req(...args) {
-  const {
-    expression,
-    useType,
-    useConverter = false,
-    useValidation = false
-  } = platformParams.mapParamsOptions(args);
-  return (target, propertyKey, parameterIndex) => {
-    const {
-      paramType,
-      dataPath
-    } = getParamType(target, propertyKey, parameterIndex);
-    platformParams.UseParam({
-      paramType,
-      dataPath,
-      expression,
-      useType,
-      useConverter,
-      useValidation
-    })(target, propertyKey, parameterIndex);
-  };
-}
-
-/**
- * Get the Next function (for express application and middleware).
- *
- * @decorator
- * @operation
- * @input
- */
-
-function Next() {
-  return platformParams.UseParam({
-    paramType: platformParams.ParamTypes.NEXT_FN,
-    dataPath: "next",
-    useConverter: false,
-    useValidation: false
-  });
-}
-
-/**
- * @returns {Function}
- * @decorator
- * @operation
- * @input
- */
-
-function Err() {
-  return platformParams.UseParam({
-    paramType: platformParams.ParamTypes.ERR,
-    dataPath: "err",
-    useValidation: false,
-    useConverter: false
-  });
-}
-
-/**
- * Get the current endpoint metadata.
- * @decorator
- * @operation
- * @input
- * @deprecated Use `@Context() $ctx: Context` then `$ctx.endpoint` instead.
- */
-
-function EndpointInfo() {
-  return platformParams.UseParam({
-    paramType: platformParams.ParamTypes.$CTX,
-    dataPath: "$ctx.endpoint",
-    useConverter: false,
-    useValidation: false
-  });
-}
-
-const _excluded = ["use", "collection"];
-
-/**
- * @ignore
- */
-function mapReturnedResponse(_ref) {
-  let {
-    use,
-    collection
-  } = _ref,
-      options = _objectWithoutPropertiesLoose(_ref, _excluded);
-
-  return _extends({}, options, {
-    type: options.type || use,
-    collectionType: options.collectionType || collection
-  });
-}
-
-/**
- * @platform
- */
-
-class PlatformTest extends di.DITest {
-  static async create(options = {}) {
-    di.DITest.injector = PlatformTest.createInjector(getConfiguration(options, null));
-    const container = di.createContainer();
-    await di.DITest.injector.load(container);
-  }
-  /**
-   * Create a new injector with the right default services
-   */
-
-
-  static createInjector(settings = {}) {
-    return createInjector(di.DITest.configure(settings));
-  }
-  /**
-   * Load the server silently without listening port and configure it on test profile.
-   * @decorator
-   * @param mod
-   * @param settings
-   * @returns {Promise<void>}
-   */
-
-
-  static bootstrap(mod, settings = {}) {
-    return async function before() {
-      let instance;
-      const platform = settings.platform || PlatformTest.platformBuilder;
-      /* istanbul ignore next */
-
-      if (!platform) {
-        throw new Error("Platform type is not specified. Have you added at least `import @tsed/platform-express` (or equivalent) on your Server.ts ?");
-      } // @ts-ignore
-
-
-      settings = di.DITest.configure(settings);
-      instance = await PlatformBuilder.build(platform, mod, settings).bootstrap();
-
-      if (!settings.listen) {
-        await instance.callHook("$beforeListen");
-        await instance.callHook("$afterListen");
-        await instance.ready();
-      } else {
-        await instance.listen();
-      } // used by inject method
-
-
-      di.DITest.injector = instance.injector;
-    };
-  }
-  /**
-   * It injects services into the test function where you can alter, spy on, and manipulate them.
-   *
-   * The inject function has two parameters
-   *
-   * * an array of Service dependency injection tokens,
-   * * a test function whose parameters correspond exactly to each item in the injection token array.
-   *
-   * @param targets
-   * @param func
-   */
-
-
-  static inject(targets, func) {
-    return async () => {
-      if (!di.DITest.hasInjector()) {
-        await PlatformTest.create();
-      }
-
-      const injector = di.DITest.injector;
-      const deps = [];
-
-      for (const target of targets) {
-        deps.push(injector.has(target) ? injector.get(target) : await injector.invoke(target));
-      }
-
-      return await func(...deps);
-    };
-  }
-  /**
-   * Return the raw application (express or koa).
-   * Use this callback with SuperTest.
-   *
-   * ```typescript
-   * let request: SuperTest.SuperTest<SuperTest.Test>;
-   * beforeEach(PlatformTest.bootstrap(Server, {
-   *   mount: {
-   *     "/rest": [ProductsController]
-   *   }
-   * }));
-   * beforeEach(() => {
-   *   request = SuperTest(PlatformTest.callback());
-   * });
-   * ```
-   */
-
-
-  static callback() {
-    var _DITest$injector$get;
-
-    return (_DITest$injector$get = di.DITest.injector.get(exports.PlatformApplication)) == null ? void 0 : _DITest$injector$get.callback();
-  }
-
-  static createRequest(options = {}) {
-    return _extends({
-      headers: {},
-
-      get(key) {
-        return this.headers[key.toLowerCase()];
-      },
-
-      accepts(mime) {
-        return require("accepts")(this).types([].concat(mime));
-      }
-
-    }, options);
-  }
-
-  static createResponse(options = {}) {
-    return _extends({
-      headers: {},
-      locals: {},
-      statusCode: 200,
-
-      status(code) {
-        this.statusCode = code;
-        return this;
-      },
-
-      contentType(content) {
-        this.set("content-type", content);
-      },
-
-      contentLength(content) {
-        this.set("content-length", content);
-      },
-
-      redirect(status, path) {
-        this.statusCode = status;
-        this.set("location", path);
-      },
-
-      location(path) {
-        this.set("location", path);
-      },
-
-      get(key) {
-        return this.headers[key.toLowerCase()];
-      },
-
-      getHeaders() {
-        return this.headers;
-      },
-
-      set(key, value) {
-        this.headers[key.toLowerCase()] = value;
-        return this;
-      },
-
-      send(data) {
-        this.data = data;
-      },
-
-      json(data) {
-        this.data = data;
-      }
-
-    }, options);
-  }
-
-  static createRequestContext(options = {}) {
-    var _options$request, _options$event, _options$response, _options$event2;
-
-    const event = {
-      request: (options == null ? void 0 : (_options$request = options.request) == null ? void 0 : _options$request.request) || (options == null ? void 0 : (_options$event = options.event) == null ? void 0 : _options$event.request) || PlatformTest.createRequest(),
-      response: (options == null ? void 0 : (_options$response = options.response) == null ? void 0 : _options$response.response) || (options == null ? void 0 : (_options$event2 = options.event) == null ? void 0 : _options$event2.response) || PlatformTest.createResponse()
-    };
-    const ctx = new PlatformContext(_extends({
-      id: "id",
-      injector: di.DITest.injector,
-      logger: di.DITest.injector.logger,
-      url: "/"
-    }, options, {
-      event
-    }));
-    ctx.response.platformViews = PlatformTest.get(platformViews.PlatformViews);
-    return ctx;
-  }
-
-}
-
-/**
- * @ignore
- * @deprecated Will be removed in v7
- */
-class PlatformModule {}
-
-Object.defineProperty(exports, '$log', {
-  enumerable: true,
-  get: function () {
-    return logger.$log;
-  }
-});
-Object.defineProperty(exports, 'Logger', {
-  enumerable: true,
-  get: function () {
-    return logger.Logger;
-  }
-});
-Object.defineProperty(exports, 'All', {
-  enumerable: true,
-  get: function () {
-    return schema.All;
-  }
-});
-Object.defineProperty(exports, 'Delete', {
-  enumerable: true,
-  get: function () {
-    return schema.Delete;
-  }
-});
-Object.defineProperty(exports, 'Get', {
-  enumerable: true,
-  get: function () {
-    return schema.Get;
-  }
-});
-Object.defineProperty(exports, 'Head', {
-  enumerable: true,
-  get: function () {
-    return schema.Head;
-  }
-});
-Object.defineProperty(exports, 'Location', {
-  enumerable: true,
-  get: function () {
-    return schema.Location;
-  }
-});
-Object.defineProperty(exports, 'Options', {
-  enumerable: true,
-  get: function () {
-    return schema.Options;
-  }
-});
-Object.defineProperty(exports, 'Patch', {
-  enumerable: true,
-  get: function () {
-    return schema.Patch;
-  }
-});
-Object.defineProperty(exports, 'Post', {
-  enumerable: true,
-  get: function () {
-    return schema.Post;
-  }
-});
-Object.defineProperty(exports, 'Put', {
-  enumerable: true,
-  get: function () {
-    return schema.Put;
-  }
-});
-Object.defineProperty(exports, 'Redirect', {
-  enumerable: true,
-  get: function () {
-    return schema.Redirect;
-  }
-});
-exports.AcceptMime = AcceptMime;
-exports.AnyToPromiseWithCtx = AnyToPromiseWithCtx;
-exports.ControllerProvider = ControllerProvider;
-exports.EndpointFn = EndpointFn;
-exports.EndpointInfo = EndpointInfo;
-exports.Err = Err;
-exports.HandlerMetadata = HandlerMetadata;
-exports.HttpServer = HttpServer;
-exports.HttpsServer = HttpsServer;
-exports.MulterFileSize = MulterFileSize;
-exports.MulterOptions = MulterOptions;
-exports.MultipartFile = MultipartFile;
-exports.Next = Next;
-exports.PLATFORM_ROUTER_OPTIONS = PLATFORM_ROUTER_OPTIONS;
-exports.PlatformBuilder = PlatformBuilder;
-exports.PlatformContext = PlatformContext;
-exports.PlatformModule = PlatformModule;
-exports.PlatformRouteDetails = PlatformRouteDetails;
-exports.PlatformTest = PlatformTest;
-exports.ROUTER_OPTIONS = ROUTER_OPTIONS;
-exports.Req = Req;
-exports.Request = Request;
-exports.Res = Res;
-exports.Response = Response;
-exports.ResponseData = ResponseData;
-exports.bindEndpointMiddleware = bindEndpointMiddleware;
-exports.buildRouter = buildRouter;
-exports.createContext = createContext;
-exports.createHttpServer = createHttpServer;
-exports.createHttpsServer = createHttpsServer;
-exports.createInjector = createInjector;
-exports.createPlatformApplication = createPlatformApplication;
-exports.createRouter = createRouter;
-exports.getRouter = getRouter;
-exports.listenHttpServer = listenHttpServer;
-exports.listenHttpsServer = listenHttpsServer;
-exports.listenServer = listenServer;
-exports.loadInjector = loadInjector;
-exports.mapReturnedResponse = mapReturnedResponse;
-exports.printRoutes = printRoutes;
-exports.useCtxHandler = useCtxHandler;
-Object.keys(di).forEach(function (k) {
-  if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
-    enumerable: true,
-    get: function () {
-      return di[k];
-    }
-  });
-});
-Object.keys(platformParams).forEach(function (k) {
-  if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
-    enumerable: true,
-    get: function () {
-      return platformParams[k];
-    }
-  });
-});
-Object.keys(platformExceptions).forEach(function (k) {
-  if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
-    enumerable: true,
-    get: function () {
-      return platformExceptions[k];
-    }
-  });
-});
-Object.keys(platformResponseFilter).forEach(function (k) {
-  if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
-    enumerable: true,
-    get: function () {
-      return platformResponseFilter[k];
-    }
-  });
-});
-Object.keys(platformCache).forEach(function (k) {
-  if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
-    enumerable: true,
-    get: function () {
-      return platformCache[k];
-    }
-  });
-});
-Object.keys(platformMiddlewares).forEach(function (k) {
-  if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
-    enumerable: true,
-    get: function () {
-      return platformMiddlewares[k];
-    }
-  });
-});
-Object.keys(platformViews).forEach(function (k) {
-  if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
-    enumerable: true,
-    get: function () {
-      return platformViews[k];
-    }
-  });
-});
-Object.keys(componentsScan).forEach(function (k) {
-  if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
-    enumerable: true,
-    get: function () {
-      return componentsScan[k];
-    }
-  });
-});
-Object.keys(platformLogMiddleware).forEach(function (k) {
-  if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
-    enumerable: true,
-    get: function () {
-      return platformLogMiddleware[k];
-    }
-  });
-});
-//# sourceMappingURL=index.js.map