Configuration Management

The configuration management module provides the core system for organizing, merging, and managing AutoRest configurations from multiple sources.

Core Classes

ConfigurationManager

class ConfigurationManager {
  constructor(configFileOrFolderUri: string, fileSystem: IFileSystem);
  addConfig(config: AutorestNormalizedConfiguration): Promise<void>;
  addHighPriorityConfig(config: AutorestNormalizedConfiguration): Promise<void>;
  addConfigFile(file: ConfigurationFile): void;
  resolveConfig(): Promise<AutorestConfiguration>;
}

Main class for organizing configurations and merging them together. Configurations are processed in priority order where first configs override later ones.

Constructor Parameters:

• configFileOrFolderUri: string - Base URI for configuration file or folder
• fileSystem: IFileSystem - File system interface for reading configuration files

Methods:

addConfig

addConfig(config: AutorestNormalizedConfiguration): Promise<void>;

Adds a configuration with normal priority. This configuration will be processed after high-priority configurations.

Parameters:

• config: AutorestNormalizedConfiguration - Configuration object to add

addHighPriorityConfig

addHighPriorityConfig(config: AutorestNormalizedConfiguration): Promise<void>;

Adds a configuration with high priority. This configuration will be loaded first and its values can be used in later configurations.

Parameters:

• config: AutorestNormalizedConfiguration - High-priority configuration object

addConfigFile

addConfigFile(file: ConfigurationFile): void;

Adds a configuration file with conditional configuration support.

Parameters:

• file: ConfigurationFile - Configuration file object to add

resolveConfig

resolveConfig(): Promise<AutorestConfiguration>;

Resolves the final AutoRestConfiguration from all added configurations, processing conditional blocks and merging all sources.

Returns:

• Promise<AutorestConfiguration> - Final merged and processed configuration

Example:

import { ConfigurationManager } from "@autorest/configuration";
import { RealFileSystem } from "@azure-tools/datastore";

const fileSystem = new RealFileSystem();
const configManager = new ConfigurationManager("./", fileSystem);

// Add CLI arguments as high priority
await configManager.addHighPriorityConfig({
  "input-file": ["swagger.json"],
  "output-folder": "./generated",
  debug: true
});

// Add default configuration
await configManager.addConfig({
  "base-folder": ".",
  "disable-validation": false
});

ConfigurationFile

interface ConfigurationFile {
  type: "file";
  fullPath: string;
  configs: ConditionalConfiguration[];
}

interface ConditionalConfiguration {
  condition?: string;
  config: AutorestNormalizedConfiguration;
}

Represents a configuration file with support for conditional configuration blocks and literate YAML processing.

Properties:

• type: "file" - Type identifier for configuration files
• fullPath: string - Full path to the configuration file
• configs: ConditionalConfiguration[] - Array of configuration blocks, each with optional conditions

Configuration File Reading

readConfigurationFile

function readConfigurationFile(
  configFile: DataHandle,
  logger: AutorestLogger,
  sink: DataSink
): Promise<ConfigurationFile>;

Reads and parses configuration files supporting multiple formats including YAML, JSON, and literate markdown with full validation and error handling.

Parameters:

• configFile: DataHandle - Data handle for the configuration file to read
• logger: AutorestLogger - Logger instance for error and progress reporting
• sink: DataSink - Data sink for processed configuration data

Returns:

• Promise<ConfigurationFile> - Parsed configuration file with conditional blocks

Default Configuration

The system includes a default configuration that provides sensible defaults:

const defaultConfig: AutorestNormalizedConfiguration;

Default values include:

• "base-folder": "." - Current directory as base
• "output-folder": "generated" - Default output folder
• debug: false - Debug mode disabled
• verbose: false - Verbose logging disabled
• "disable-validation": false - Validation enabled

Configuration Priority

Configurations are processed in the following priority order:

1. High-priority configurations (added via addHighPriorityConfig)

   • CLI arguments
   • Override configurations

2. Normal configurations (added via addConfig)

   • Configuration files
   • Default configurations

3. System defaults

   • Built-in default values

Higher priority configurations override values from lower priority configurations.

Configuration Types

SimpleConfiguration

interface SimpleConfiguration {
  type: "simple";
  config: AutorestNormalizedConfiguration;
}

Represents a simple configuration object with normalized values.

ConditionalConfiguration

interface ConditionalConfiguration {
  // Conditional configuration support for guard expressions
}

Supports conditional configuration blocks that are evaluated based on context and guard expressions.

Usage Patterns

Basic Configuration Management

import { ConfigurationManager } from "@autorest/configuration";
import { RealFileSystem } from "@azure-tools/datastore";

const configManager = new ConfigurationManager("./config", new RealFileSystem());

// Add configurations in priority order
await configManager.addHighPriorityConfig(cliConfig);
await configManager.addConfig(fileConfig);
await configManager.addConfig(defaultConfig);

// Build final merged configuration
const finalConfig = await configManager.resolveConfig();

Multiple Configuration Sources

// CLI arguments (highest priority)
await configManager.addHighPriorityConfig(parsedCliArgs.options);

// Project-specific configuration
await configManager.addConfig(projectConfig);

// Global configuration
await configManager.addConfig(globalConfig);

// Defaults (lowest priority)
await configManager.addConfig(defaultConfig);