async function configureHostedWithAAD()

in src/hooks/useKnockoutExplorer.ts [321:432]
107 lines of code
23 McCabe index (conditional complexity)

async function configureHostedWithAAD(config: AAD): Promise<Explorer> {
  // TODO: Refactor. updateUserContext needs to be called twice because listKeys below depends on userContext.authorizationToken
  updateUserContext({
    authType: AuthType.AAD,
    authorizationToken: `Bearer ${config.authorizationToken}`,
  });
  const account = config.databaseAccount;
  const accountResourceId = account.id;
  const subscriptionId = accountResourceId && accountResourceId.split("subscriptions/")[1].split("/")[0];
  const resourceGroup = accountResourceId && accountResourceId.split("resourceGroups/")[1].split("/")[0];
  let aadToken;
  if (account.properties?.documentEndpoint) {
    const hrefEndpoint = new URL(account.properties.documentEndpoint).href.replace(/\/$/, "/.default");
    const msalInstance = await getMsalInstance();
    const cachedAccount = msalInstance.getAllAccounts()?.[0];
    msalInstance.setActiveAccount(cachedAccount);
    const cachedTenantId = localStorage.getItem("cachedTenantId");
    try {
      aadToken = await acquireTokenWithMsal(msalInstance, {
        forceRefresh: true,
        scopes: [hrefEndpoint],
        authority: `${configContext.AAD_ENDPOINT}${cachedTenantId}`,
      });
    } catch (authError) {
      logConsoleError("Failed to acquire authorization token: " + authError);
    }
  }
  try {
    updateUserContext({
      databaseAccount: config.databaseAccount,
    });
    Logger.logInfo(
      `Configuring Data Explorer for ${userContext.apiType} account ${account.name}`,
      "Explorer/configureHostedWithAAD",
    );
    if (userContext.apiType === "SQL") {
      checkAndUpdateSelectedRegionalEndpoint();
    }
    if (!userContext.features.enableAadDataPlane) {
      Logger.logInfo(`AAD Feature flag is not enabled for account ${account.name}`, "Explorer/configureHostedWithAAD");
      if (isDataplaneRbacSupported(userContext.apiType)) {
        if (LocalStorageUtility.hasItem(StorageKey.DataPlaneRbacEnabled)) {
          const isDataPlaneRbacSetting = LocalStorageUtility.getEntryString(StorageKey.DataPlaneRbacEnabled);
          Logger.logInfo(
            `Local storage RBAC setting for ${userContext.apiType} account ${account.name} is ${isDataPlaneRbacSetting}`,
            "Explorer/configureHostedWithAAD",
          );

          let dataPlaneRbacEnabled;
          if (isDataPlaneRbacSetting === Constants.RBACOptions.setAutomaticRBACOption) {
            dataPlaneRbacEnabled = account.properties.disableLocalAuth;
            Logger.logInfo(
              `Data Plane RBAC value for ${userContext.apiType} account ${account.name} with disable local auth set to ${account.properties.disableLocalAuth} is ${dataPlaneRbacEnabled}`,
              "Explorer/configureHostedWithAAD",
            );
          } else {
            dataPlaneRbacEnabled = isDataPlaneRbacSetting === Constants.RBACOptions.setTrueRBACOption;
            Logger.logInfo(
              `Data Plane RBAC value for ${userContext.apiType} account ${account.name} with disable local auth set to ${account.properties.disableLocalAuth} is ${dataPlaneRbacEnabled}`,
              "Explorer/configureHostedWithAAD",
            );
          }
          if (!dataPlaneRbacEnabled) {
            Logger.logInfo(
              `Calling fetch keys for ${userContext.apiType} account ${account.name} with RBAC setting ${dataPlaneRbacEnabled}`,
              "Explorer/configureHostedWithAAD",
            );
            await fetchAndUpdateKeys(subscriptionId, resourceGroup, account.name);
          }

          updateUserContext({ dataPlaneRbacEnabled });
        } else {
          const dataPlaneRbacEnabled = account.properties.disableLocalAuth;
          Logger.logInfo(
            `Local storage setting does not exist : Data Plane RBAC value for ${userContext.apiType} account ${account.name} with disable local auth set to ${account.properties.disableLocalAuth} is ${dataPlaneRbacEnabled}`,
            "Explorer/configureHostedWithAAD",
          );

          if (!dataPlaneRbacEnabled) {
            Logger.logInfo(
              `Fetching keys for ${userContext.apiType} account ${account.name} with RBAC setting ${dataPlaneRbacEnabled}`,
              "Explorer/configureHostedWithAAD",
            );
            await fetchAndUpdateKeys(subscriptionId, resourceGroup, account.name);
          }

          updateUserContext({ dataPlaneRbacEnabled });
          useDataPlaneRbac.setState({ dataPlaneRbacEnabled: dataPlaneRbacEnabled });
        }
      } else {
        Logger.logInfo(
          `Fetching keys for ${userContext.apiType} account ${account.name}`,
          "Explorer/configureHostedWithAAD",
        );
        await fetchAndUpdateKeys(subscriptionId, resourceGroup, account.name);
      }
    }
  } catch (e) {
    if (userContext.features.enableAadDataPlane) {
      console.warn(e);
    } else {
      throw new Error(`List keys failed: ${e.message}`);
    }
  }
  updateUserContext({
    subscriptionId,
    resourceGroup,
    aadToken,
  });
  const explorer = new Explorer();
  return explorer;
}