async function initializeAsync()

in middleware/initialize.ts [88:251]
138 lines of code
23 McCabe index (conditional complexity)

async function initializeAsync(app: IReposApplication, express, rootdir: string, config): Promise<void> {
  const providers = app.get('providers') as IProviders;
  providers.postgresPool = await ConnectPostgresPool(config.data.postgres);
  providers.linkProvider = await createAndInitializeLinkProviderInstance(providers, config);
  if (config.github.cache.provider === 'cosmosdb') {
    const cosmosCache = new CosmosCache(config.github.cache.cosmosdb);
    await cosmosCache.initialize();
    providers.cacheProvider = cosmosCache;
  } else if (config.github.cache.provider === 'blob') {
    const blobCache = new BlobCache(config.github.cache.blob);
    await blobCache.initialize();
    providers.cacheProvider = blobCache;
  } else if (config.github.cache.provider === 'redis') {
    const redisClient = await connectRedis(config, config.redis, 'cache');
    const redisHelper = new RedisHelper({ redisClient, prefix: config.redis.prefix });
    // providers.redisClient = redisClient;
    providers.cacheProvider = redisHelper;
  } else {
    throw new Error('No cache provider available');
  }

  providers.graphProvider = await createGraphProvider(providers, config);
  app.set('graphProvider', providers.graphProvider);

  providers.mailAddressProvider = await createMailAddressProvider(config, providers);
  app.set('mailAddressProvider', providers.mailAddressProvider);

  const mailProvider = createMailProviderInstance(config);
  const mailInitializedMessage = await mailProvider.initialize();
  debug(`mail provider type=${config.mail.provider} ${mailInitializedMessage}`);
  providers.mailProvider = mailProvider;

  providers.github = configureGitHubLibrary(providers.cacheProvider, config);
  app.set('github', providers.github);

  // always check if config exists to prevent crashing because of trying to access an undefined object
  const emOptions: IEntityMetadataProvidersOptions = {
    tableOptions: {
      account: config.github?.links?.table?.account,
      key: config.github?.links?.table?.key,
      prefix: config.github?.links?.table?.prefix,
      encryption: {
        keyEncryptionKeyId: config.github?.links?.table?.encryptionKeyId,
        keyResolver: providers.keyEncryptionKeyResolver,
      },
    },
    postgresOptions: {
      pool: providers.postgresPool,
    },
  };
  let tableProviderEnabled = emOptions.tableOptions && emOptions.tableOptions.account && emOptions.tableOptions.key;
  let postgresProviderEnabled = emOptions.postgresOptions && emOptions.postgresOptions.pool;
  const tableEntityMetadataProvider = tableProviderEnabled ? await createAndInitializeEntityMetadataProviderInstance(
    emOptions,
    'table') : null;
  const pgEntityMetadataProvider = postgresProviderEnabled ? await createAndInitializeEntityMetadataProviderInstance(
    emOptions,
    'postgres') : null;
  const memoryEntityMetadataProvider = await createAndInitializeEntityMetadataProviderInstance(
    emOptions,
    'memory');
  const defaultProvider = pgEntityMetadataProvider || tableEntityMetadataProvider || memoryEntityMetadataProvider;
  function providerNameToInstance(value: string): IEntityMetadataProvider {
    switch (value) {
      case 'firstconfigured':
        return defaultProvider;
      case 'postgres':
        return pgEntityMetadataProvider;
      case 'table':
        return tableEntityMetadataProvider;
      case 'memory':
        return memoryEntityMetadataProvider;
      default:
        return null;
    }
  }
  providers['_temp:nameToInstance'] = providerNameToInstance;
  providers.defaultEntityMetadataProvider = defaultProvider;
  providers.approvalProvider = await createAndInitializeApprovalProviderInstance({ entityMetadataProvider: providerNameToInstance(config.entityProviders.teamjoin) });
  providers.tokenProvider = await createTokenProvider({ entityMetadataProvider: providerNameToInstance(config.entityProviders.tokens) });
  providers.localExtensionKeyProvider = await CreateLocalExtensionKeyProvider({ entityMetadataProvider: providerNameToInstance(config.entityProviders.localextensionkey) });
  providers.organizationMemberCacheProvider = await CreateOrganizationMemberCacheProviderInstance({ entityMetadataProvider: providerNameToInstance(config.entityProviders.organizationmembercache) });
  providers.organizationSettingsProvider = await createAndInitializeOrganizationSettingProviderInstance({ entityMetadataProvider: providerNameToInstance(config.entityProviders.organizationsettings) });
  providers.repositoryCacheProvider = await CreateRepositoryCacheProviderInstance({ entityMetadataProvider: providerNameToInstance(config.entityProviders.repositorycache) });
  providers.repositoryCollaboratorCacheProvider = await CreateRepositoryCollaboratorCacheProviderInstance({ entityMetadataProvider: providerNameToInstance(config.entityProviders.repositorycollaboratorcache) });
  providers.repositoryTeamCacheProvider = await CreateRepositoryTeamCacheProviderInstance({ entityMetadataProvider: providerNameToInstance(config.entityProviders.repositoryteamcache) });
  providers.teamCacheProvider = await CreateTeamCacheProviderInstance({ entityMetadataProvider: providerNameToInstance(config.entityProviders.teamcache) });
  providers.teamMemberCacheProvider = await CreateTeamMemberCacheProviderInstance({ entityMetadataProvider: providerNameToInstance(config.entityProviders.teammembercache) });
  providers.auditLogRecordProvider = await createAndInitializeAuditLogRecordProviderInstance({ entityMetadataProvider: providerNameToInstance(config.entityProviders.auditlogrecord) });
  providers.userSettingsProvider = new UserSettingsProvider({ entityMetadataProvider: providerNameToInstance(config.entityProviders.usersettings) });
  providers.repositoryProvider = await initializeRepositoryProvider({ entityMetadataProvider: providerNameToInstance(config.entityProviders.repository) });
  await providers.userSettingsProvider.initialize();
  providers.queryCache = new QueryCache(providers);
  if (config.campaigns && config.campaigns.provider === 'cosmosdb') {
    const campaignCosmosStore = new CosmosHelper({
      endpoint: config.campaigns.cosmosdb.endpoint,
      key: config.campaigns.cosmosdb.key,
      database: config.campaigns.cosmosdb.database,
      collection: config.campaigns.cosmosdb.collection,
    });
    await campaignCosmosStore.initialize();
    providers.campaignStateProvider = new StatefulCampaignProvider(campaignCosmosStore);
  }
  if (config.session.provider === 'cosmosdb') {
    const cosmosStore = new CosmosSessionStore({
      endpoint: config.session.cosmosdb.endpoint,
      key: config.session.cosmosdb.key,
      database: config.session.cosmosdb.database,
      collection: config.session.cosmosdb.collection,
      ttl: config.session.cosmosdb.ttl,
    });
    await cosmosStore.initialize();
    providers.session = cosmosStore;
  } else if (config.session.provider === 'redis') {
    const redisSessionClient = await connectRedis(config, config.session.redis, 'session');
    providers.sessionRedisClient = redisSessionClient;
  }
  if (config?.diagnostics?.blob?.key) {
    providers.diagnosticsDrop = new BlobCache({
      key: config.diagnostics.blob.key,
      account: config.diagnostics.blob.account,
      container: config.diagnostics.blob.container,
    });
    await providers.diagnosticsDrop.initialize();
  }

  providers.corporateContactProvider = createCorporateContactProviderInstance(config, providers.cacheProvider);
  providers.corporateAdministrationProfile = getCompanySpecificDeployment()?.administrationSection;
  providers.corporateViews = await initializeCorporateViews(providers, rootdir);

  await dynamicStartup(config, providers, rootdir);

  const webhooksConfig = config.github.webhooks;
  if (webhooksConfig && webhooksConfig.provider) {
    let webhooksProvider: IQueueProcessor = null;
    if (webhooksConfig.provider === 'servicebus') {
      const serviceBusConfig = webhooksConfig.serviceBus;
      webhooksProvider = new ServiceBusQueueProcessor(serviceBusConfig);
    } else if (webhooksConfig.provider === 'azurequeues') {
      const queuesConfig = webhooksConfig.azureQueues;
      webhooksProvider = new AzureQueuesProcessor(queuesConfig);
    }
    if (webhooksProvider) {
      await webhooksProvider.initialize();
      providers.webhookQueueProcessor = webhooksProvider;
    }
  }

  try {
    const repositoryMetadataProvider = await createAndInitializeRepositoryMetadataProviderInstance({ entityMetadataProvider: providerNameToInstance(config.entityProviders.repositorymetadata) });
    const operations = new Operations({ providers, repositoryMetadataProvider, github: providers.github });
    await operations.initialize();
    app.set('operations', operations);
    providers.operations = operations;
  } catch (ignoredError2) {
    console.dir(ignoredError2);
    throw ignoredError2;
  }

  if (providers.applicationProfile.startup) {
    debug('Application provider-specific startup...');
    await providers.applicationProfile.startup(providers);
  }
}