public async load()

in packages/libs/configuration/src/configuration-loader/configuration-loader.ts [78:190]
84 lines of code
19 McCabe index (conditional complexity)

  public async load(
    configs: AutorestRawConfiguration[],
    includeDefault: boolean,
  ): Promise<AutorestConfigurationResult> {
    const configFileUri = this.configFileOrFolderUri
      ? await detectConfigurationFile(this.fileSystem, this.configFileOrFolderUri, this.logger)
      : undefined;

    const configFileFolderUri = configFileUri
      ? resolveUri(configFileUri, "./")
      : this.configFileOrFolderUri || "file:///";

    const manager = new ConfigurationManager(configFileFolderUri, this.fileSystem);

    const resolveConfig = () => manager.resolveConfig();
    const addedConfigs = new Set<string>();

    const loadConfigFile = async (fileUri: string, fsToUse: IFileSystem) => {
      return this.loadConfigFile(fileUri, fsToUse, manager, addedConfigs);
    };

    const resolveRequiredConfigs = async (fsToUse: IFileSystem) => {
      return this.resolveRequiredConfigs(manager, fsToUse, addedConfigs);
    };

    // 1. overrides (CLI, ...)
    // await addSegments(configs, false);
    for (const rawConfig of configs) {
      const result = autorestConfigurationProcessor.processConfiguration(rawConfig, { logger: this.logger });
      if ("errors" in result) {
        for (const error of result.errors) {
          this.logger.trackError({
            code: error.code,
            message: error.message,
          });
        }
        throw new OperationAbortedException();
      }
      await manager.addConfig(result.value);
    }
    await resolveRequiredConfigs(this.fileSystem);
    // 2. file
    if (configFileUri != null && configFileUri !== undefined) {
      // add loaded files to the input files.
      this.logger.verbose(`> Initial configuration file '${configFileUri}'`);
      await loadConfigFile(configFileUri, this.fileSystem);
    }

    // 3. default configuration
    const fsLocal = new RealFileSystem();
    if (includeDefault) {
      await loadConfigFile(this.defaultConfigUri, fsLocal);
    }

    // 4. resolve extensions
    const extensions: ResolvedExtension[] = [];
    if (this.extensionManager) {
      const addedExtensions = new Set<string>();
      const viewsToHandle: AutorestNormalizedConfiguration[] = [await resolveConfig()];
      while (viewsToHandle.length > 0) {
        const config = viewsToHandle.pop() as AutorestNormalizedConfiguration;
        const extensionDefs = resolveExtensions(config);

        const additionalExtensions = extensionDefs.filter((ext) => !addedExtensions.has(ext.fullyQualified));
        await manager.addConfig({ "used-extension": additionalExtensions.map((x) => x.fullyQualified) });
        if (additionalExtensions.length === 0) {
          continue;
        }

        // acquire additional extensions
        for (const additionalExtension of additionalExtensions) {
          try {
            addedExtensions.add(additionalExtension.fullyQualified);

            const extension = await this.resolveExtension(this.extensionManager, additionalExtension);
            extensions.push({ extension, definition: additionalExtension });

            // merge config from extension
            const extensionConfigurationUri = simplifyUri(createFileUri(await extension.configurationPath));
            this.logger.verbose(`> Including extension configuration file '${extensionConfigurationUri}'`);
            await loadConfigFile(extensionConfigurationUri, fsLocal);

            viewsToHandle.push(await resolveConfig());
          } catch (e) {
            this.logger.fatal(
              `Failed to install extension '${additionalExtension.name}' (${additionalExtension.source})`,
            );
            throw e;
          }
        }
        await resolveRequiredConfigs(fsLocal);
      }
    }

    // resolve any outstanding includes again
    await resolveRequiredConfigs(fsLocal);
    const config = await manager.resolveConfig();
    // If the pipeline-model was set we set it at the beginning and reload the config.
    // There is some configuration in `default-configuration.md` that depends on pipeline-model but some plugins are setting up pipeline-model.

    // Perform-load false disable the loaders(swagger, openapi3, cadl.)
    // Default should be true. Check if it not set first and if allow-no-input is not there.
    if (config["perform-load"] === undefined) {
      if (!config["allow-no-input"] && !config["help"]) {
        await manager.addConfig({ "perform-load": true });
      }
    }

    if (config["pipeline-model"]) {
      await manager.addHighPriorityConfig({ "pipeline-model": config["pipeline-model"] });
    }
    return { config: await manager.resolveConfig(), extensions };
  }