Method _createHttpHandler

packages/rest/src/rest.server.ts:423–489

* Create an instance of HttpHandler and populates it with routes

()

   * Create an instance of HttpHandler and populates it with routes
   */
  private _createHttpHandler() {
    /**
     * Check if there is custom router in the context
     */
    const router = this.getSync(RestBindings.ROUTER, {optional: true});
    const routingTable = new RoutingTable(router, this._externalRoutes);

    this._httpHandler = new HttpHandler(this, this.config, routingTable);

    // Remove controller routes
    for (const b of this.findByTag(RestTags.CONTROLLER_ROUTE)) {
      this.unbind(b.key);
    }

    for (const b of this.find(`${CoreBindings.CONTROLLERS}.*`)) {
      const controllerName = b.key.replace(/^controllers\./, '');
      const ctor = b.valueConstructor;
      if (!ctor) {
        throw new Error(
          `The controller ${controllerName} was not bound via .toClass()`,
        );
      }
      const apiSpec = getControllerSpec(ctor);
      if (!apiSpec) {
        // controller methods are specified through app.api() spec
        debug('Skipping controller %s - no API spec provided', controllerName);
        continue;
      }

      debug('Registering controller %s', controllerName);
      if (apiSpec.components) {
        this._httpHandler.registerApiComponents(apiSpec.components);
      }
      const controllerFactory = createControllerFactoryForBinding<object>(
        b.key,
      );
      const routes = createRoutesForController(
        apiSpec,
        ctor,
        controllerFactory,
      );
      for (const route of routes) {
        const binding = this.bindRoute(route);
        binding
          .tag(RestTags.CONTROLLER_ROUTE)
          .tag({[RestTags.CONTROLLER_BINDING]: b.key});
      }
    }

    for (const b of this.findByTag(RestTags.REST_ROUTE)) {
      // TODO(bajtos) should we support routes defined asynchronously?
      const route = this.getSync<RouteEntry>(b.key);
      this._httpHandler.registerRoute(route);
    }

    // TODO(bajtos) should we support API spec defined asynchronously?
    const spec: OpenApiSpec = this.getSync(RestBindings.API_SPEC);
    if (spec.components) {