public createRequestListener()

in src/blob/BlobRequestListenerFactory.ts [62:226]
121 lines of code
6 McCabe index (conditional complexity)

  public createRequestListener(): RequestListener {
    const app = express().disable("x-powered-by");

    // MiddlewareFactory is a factory to create auto-generated middleware
    const middlewareFactory: MiddlewareFactory = new ExpressMiddlewareFactory(
      logger,
      DEFAULT_CONTEXT_PATH
    );

    // Create handlers into handler middleware factory
    const pageBlobRangesManager = new PageBlobRangesManager();

    const loose = this.loose || false;
    const handlers: IHandlers = {
      appendBlobHandler: new AppendBlobHandler(
        this.metadataStore,
        this.extentStore,
        logger,
        loose
      ),
      blobHandler: new BlobHandler(
        this.metadataStore,
        this.extentStore,
        logger,
        loose,
        pageBlobRangesManager
      ),
      blockBlobHandler: new BlockBlobHandler(
        this.metadataStore,
        this.extentStore,
        logger,
        loose
      ),
      containerHandler: new ContainerHandler(
        this.accountDataStore,
        this.oauth,
        this.metadataStore,
        this.extentStore,
        logger,
        loose,
        this.disableProductStyleUrl
      ),
      pageBlobHandler: new PageBlobHandler(
        this.metadataStore,
        this.extentStore,
        logger,
        loose,
        pageBlobRangesManager
      ),
      serviceHandler: new ServiceHandler(
        this.accountDataStore,
        this.oauth,
        this.metadataStore,
        this.extentStore,
        logger,
        loose,
        this.disableProductStyleUrl
      )
    };

    // CORS request handling, preflight request and the corresponding actual request
    const preflightMiddlewareFactory = new PreflightMiddlewareFactory(logger);

    // Send Telemetry data
    const telemetryMiddlewareFactory = new TelemetryMiddlewareFactory(
      DEFAULT_CONTEXT_PATH);

    // Strict mode unsupported features blocker
    const strictModelMiddlewareFactory = new StrictModelMiddlewareFactory(
      logger,
      [UnsupportedHeadersBlocker, UnsupportedParametersBlocker]
    );

    /*
     * Generated middleware should follow strict orders
     * Manually created middleware can be injected into any points
     */

    // Access log per request
    if (this.enableAccessLog) {
      app.use(morgan("common", { stream: this.accessLogWriteStream }));
    }

    // Manually created middleware to deserialize feature related context which swagger doesn't know
    app.use(createStorageBlobContextMiddleware(this.skipApiVersionCheck, this.disableProductStyleUrl, this.loose));

    // Dispatch incoming HTTP request to specific operation
    app.use(middlewareFactory.createDispatchMiddleware());

    // Block unsupported features in strict mode by default
    if (this.loose === false || this.loose === undefined) {
      app.use(strictModelMiddlewareFactory.createStrictModelMiddleware());
    }

    // AuthN middleware, like shared key auth or SAS auth
    const authenticationMiddlewareFactory = new AuthenticationMiddlewareFactory(
      logger
    );
    const authenticators: IAuthenticator[] = [
      new PublicAccessAuthenticator(this.metadataStore, logger),
      new BlobSharedKeyAuthenticator(this.accountDataStore, logger),
      new AccountSASAuthenticator(
        this.accountDataStore,
        this.metadataStore,
        logger
      ),
      new BlobSASAuthenticator(
        this.accountDataStore,
        this.metadataStore,
        logger
      )
    ];
    if (this.oauth !== undefined) {
      authenticators.push(
        new BlobTokenAuthenticator(this.accountDataStore, this.oauth, logger)
      );
    }
    app.use(
      authenticationMiddlewareFactory.createAuthenticationMiddleware(
        authenticators
      )
    );

    // Generated, will do basic validation defined in swagger
    app.use(middlewareFactory.createDeserializerMiddleware());

    // Generated, inject handlers to create a handler middleware
    app.use(middlewareFactory.createHandlerMiddleware(handlers));

    // CORS
    app.use(
      preflightMiddlewareFactory.createCorsRequestMiddleware(
        this.metadataStore,
        true
      )
    );
    app.use(
      preflightMiddlewareFactory.createCorsRequestMiddleware(
        this.metadataStore,
        false
      )
    );

    // Generated, will serialize response models into HTTP response
    app.use(middlewareFactory.createSerializerMiddleware());

    // Preflight
    app.use(
      preflightMiddlewareFactory.createOptionsHandlerMiddleware(
        this.metadataStore
      )
    );


    // Generated, will return MiddlewareError and Errors thrown in previous middleware/handlers to HTTP response
    app.use(middlewareFactory.createErrorMiddleware());

    // Send out telemetry data
    app.use(telemetryMiddlewareFactory.createTelemetryMiddleware());

    // Generated, will end and return HTTP response immediately
    app.use(middlewareFactory.createEndMiddleware());

    return app;
  }