@microsoft/terraform-cdk-constructs 0.0.3-pre.6 → 1.0.0

package/lib/core-azure/lib/version-manager/api-version-manager.js

@@ -0,0 +1,509 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiVersionManager = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/**
+ * ApiVersionManager - A JSII-compliant singleton for managing Azure API versions
+ *
+ * This class provides centralized version management for Azure resources, including:
+ * - Version registry and metadata storage
+ * - Version resolution and compatibility analysis
+ * - Migration analysis between versions
+ * - Thread-safe singleton operations
+ *
+ * The singleton pattern is implemented in a JSII-compliant way using instance methods
+ * rather than static classes to ensure multi-language compatibility.
+ *
+ * @packageDocumentation
+ */
+const version_interfaces_1 = require("./interfaces/version-interfaces");
+/**
+ * ApiVersionManager singleton class for centralized version management
+ *
+ * This class manages API versions for Azure resources, providing version resolution,
+ * compatibility analysis, and migration guidance. It implements a JSII-compliant
+ * singleton pattern for thread-safe operations across multiple language bindings.
+ *
+ * Key Features:
+ * - Thread-safe singleton implementation
+ * - Version registry management with full lifecycle support
+ * - Advanced version resolution with constraint-based selection
+ * - Comprehensive migration analysis with effort estimation
+ * - Extensive validation and error handling
+ *
+ * @example
+ * const manager = ApiVersionManager.getInstance();
+ * manager.registerResourceType('Microsoft.Resources/resourceGroups', versions);
+ * const latest = manager.getLatestVersion('Microsoft.Resources/resourceGroups');
+ * const analysis = manager.analyzeMigration('Microsoft.Resources/resourceGroups', '2024-01-01', '2024-11-01');
+ *
+ * @stability stable
+ */
+class ApiVersionManager {
+    /**
+     * Gets the singleton instance of ApiVersionManager
+     *
+     * This method implements a thread-safe singleton pattern that's compatible
+     * with JSII multi-language bindings. The instance is lazily created on
+     * first access and reused for all subsequent calls.
+     *
+     * @returns The singleton ApiVersionManager instance
+     *
+     * @example
+     * const manager = ApiVersionManager.instance();
+     */
+    static instance() {
+        if (!ApiVersionManager._instance) {
+            ApiVersionManager._instance = new ApiVersionManager();
+        }
+        return ApiVersionManager._instance;
+    }
+    /**
+     * Private constructor to enforce singleton pattern
+     * Initializes the internal registries and data structures
+     */
+    constructor() {
+        this._resourceRegistry = {};
+    }
+    /**
+     * Registers a resource type with its version configurations
+     *
+     * This method stores version metadata for a specific Azure resource type,
+     * including schemas, lifecycle information, and migration data. It validates
+     * the input and maintains internal indexes for efficient lookups.
+     *
+     * @param resourceType - The Azure resource type (e.g., 'Microsoft.Resources/resourceGroups')
+     * @param versions - Array of version configurations for the resource type
+     *
+     * @throws Error if resourceType is empty or versions array is empty
+     * @throws Error if duplicate versions are found in the versions array
+     * @throws Error if version configurations are invalid
+     *
+     * @example
+     * manager.registerResourceType('Microsoft.Resources/resourceGroups', [
+     *   {
+     *     version: '2024-01-01',
+     *     schema: { resourceType: 'Microsoft.Resources/resourceGroups', version: '2024-01-01', properties: {}, required: [] },
+     *     supportLevel: VersionSupportLevel.ACTIVE,
+     *     releaseDate: '2024-01-01'
+     *   }
+     * ]);
+     */
+    registerResourceType(resourceType, versions) {
+        this._validateResourceTypeInput(resourceType, versions);
+        const versionMap = {};
+        let latestVersion;
+        let latestReleaseDate = new Date(0); // Start with epoch
+        // Process and validate each version
+        for (const versionConfig of versions) {
+            this._validateVersionConfig(versionConfig, resourceType);
+            // Check for duplicate versions
+            if (versionConfig.version in versionMap) {
+                throw new Error(`Duplicate version '${versionConfig.version}' found for resource type '${resourceType}'`);
+            }
+            versionMap[versionConfig.version] = versionConfig;
+            // Track the latest version based on release date and support level
+            const releaseDate = new Date(versionConfig.releaseDate);
+            if (releaseDate >= latestReleaseDate &&
+                versionConfig.supportLevel === version_interfaces_1.VersionSupportLevel.ACTIVE) {
+                latestVersion = versionConfig.version;
+                latestReleaseDate = releaseDate;
+            }
+        }
+        // Store the registry entry
+        const registryEntry = {
+            resourceType,
+            versions: versionMap,
+            latestVersion,
+        };
+        this._resourceRegistry[resourceType] = registryEntry;
+    }
+    /**
+     * Gets the latest active version for a resource type
+     *
+     * Returns the most recent version with ACTIVE support level. If no active
+     * versions are found, returns the most recent version regardless of support level.
+     *
+     * @param resourceType - The Azure resource type to get the latest version for
+     * @returns The latest version string, or undefined if the resource type is not registered
+     *
+     * @example
+     * const latest = manager.latestVersion('Microsoft.Resources/resourceGroups');
+     * // Returns: "2024-11-01"
+     */
+    latestVersion(resourceType) {
+        const registry = this._resourceRegistry[resourceType];
+        if (!registry) {
+            return undefined;
+        }
+        return registry.latestVersion;
+    }
+    /**
+     * Gets the configuration for a specific version of a resource type
+     *
+     * Retrieves the complete version configuration including schema, lifecycle
+     * information, breaking changes, and migration metadata.
+     *
+     * @param resourceType - The Azure resource type
+     * @param version - The specific version to retrieve
+     * @returns The version configuration, or undefined if not found
+     *
+     * @example
+     * const config = manager.versionConfig('Microsoft.Resources/resourceGroups', '2024-01-01');
+     * if (config) {
+     *   console.log(`Support level: ${config.supportLevel}`);
+     *   console.log(`Release date: ${config.releaseDate}`);
+     * }
+     */
+    versionConfig(resourceType, version) {
+        const registry = this._resourceRegistry[resourceType];
+        if (!registry) {
+            return undefined;
+        }
+        return registry.versions[version];
+    }
+    /**
+     * Gets all supported versions for a resource type
+     *
+     * Returns an array of all registered version strings for the specified
+     * resource type, sorted by release date (newest first).
+     *
+     * @param resourceType - The Azure resource type
+     * @returns Array of supported version strings, empty if resource type not registered
+     *
+     * @example
+     * const versions = manager.supportedVersions('Microsoft.Resources/resourceGroups');
+     * // Returns: ["2024-11-01", "2024-01-01", "2023-07-01"]
+     */
+    supportedVersions(resourceType) {
+        const registry = this._resourceRegistry[resourceType];
+        if (!registry) {
+            return [];
+        }
+        // Sort versions by release date (newest first)
+        return Object.values(registry.versions)
+            .sort((a, b) => new Date(b.releaseDate).getTime() - new Date(a.releaseDate).getTime())
+            .map((config) => config.version);
+    }
+    /**
+     * Analyzes migration requirements between two versions
+     *
+     * Performs comprehensive analysis of the migration path between source and
+     * target versions, including compatibility assessment, breaking changes
+     * identification, effort estimation, and upgrade feasibility.
+     *
+     * @param resourceType - The Azure resource type
+     * @param fromVersion - The source version to migrate from
+     * @param toVersion - The target version to migrate to
+     * @returns Detailed migration analysis results
+     *
+     * @throws Error if either version is not registered for the resource type
+     * @throws Error if resourceType is not registered
+     *
+     * @example
+     * const analysis = manager.analyzeMigration(
+     *   'Microsoft.Resources/resourceGroups',
+     *   '2024-01-01',
+     *   '2024-11-01'
+     * );
+     *
+     * console.log(`Compatible: ${analysis.compatible}`);
+     * console.log(`Effort: ${analysis.estimatedEffort}`);
+     * console.log(`Breaking changes: ${analysis.breakingChanges.length}`);
+     */
+    analyzeMigration(resourceType, fromVersion, toVersion) {
+        // Validate inputs and get configurations
+        const fromConfig = this.versionConfig(resourceType, fromVersion);
+        const toConfig = this.versionConfig(resourceType, toVersion);
+        if (!fromConfig) {
+            throw new Error(`Source version '${fromVersion}' not found for resource type '${resourceType}'`);
+        }
+        if (!toConfig) {
+            throw new Error(`Target version '${toVersion}' not found for resource type '${resourceType}'`);
+        }
+        // Analyze compatibility and changes
+        const allBreakingChanges = this._collectBreakingChanges(resourceType, fromVersion, toVersion);
+        const compatible = allBreakingChanges.length === 0;
+        const warnings = this._generateMigrationWarnings(fromConfig, toConfig);
+        const estimatedEffort = this._calculateMigrationEffort(allBreakingChanges);
+        const automaticUpgradePossible = this._canAutoUpgrade(allBreakingChanges);
+        return {
+            fromVersion,
+            toVersion,
+            compatible,
+            breakingChanges: allBreakingChanges,
+            warnings,
+            estimatedEffort,
+            automaticUpgradePossible,
+        };
+    }
+    /**
+     * Validates whether a version is supported for a resource type
+     *
+     * Checks if the specified version is registered and available for use
+     * with the given resource type.
+     *
+     * @param resourceType - The Azure resource type
+     * @param version - The version to validate
+     * @returns True if the version is supported, false otherwise
+     *
+     * @example
+     * if (manager.validateVersionSupport('Microsoft.Resources/resourceGroups', '2024-01-01')) {
+     *   // Version is supported, proceed with resource creation
+     * } else {
+     *   // Handle unsupported version
+     * }
+     */
+    validateVersionSupport(resourceType, version) {
+        const registry = this._resourceRegistry[resourceType];
+        if (!registry) {
+            return false;
+        }
+        return version in registry.versions;
+    }
+    /**
+     * Gets all registered resource types
+     *
+     * Returns an array of all Azure resource types that have been registered
+     * with the version manager.
+     *
+     * @returns Array of registered resource type strings
+     *
+     * @example
+     * const resourceTypes = manager.registeredResourceTypes();
+     * // Returns: ["Microsoft.Resources/resourceGroups", "Microsoft.Storage/storageAccounts", ...]
+     */
+    registeredResourceTypes() {
+        return Object.keys(this._resourceRegistry);
+    }
+    /**
+     * Gets version lifecycle information for a specific version
+     *
+     * Provides lifecycle metadata including current phase, transition dates,
+     * and projected sunset timeline.
+     *
+     * @param resourceType - The Azure resource type
+     * @param version - The version to get lifecycle information for
+     * @returns Version lifecycle information, or undefined if not found
+     *
+     * @example
+     * const lifecycle = manager.versionLifecycle('Microsoft.Resources/resourceGroups', '2024-01-01');
+     * if (lifecycle) {
+     *   console.log(`Current phase: ${lifecycle.phase}`);
+     *   console.log(`Sunset date: ${lifecycle.estimatedSunsetDate}`);
+     * }
+     */
+    versionLifecycle(resourceType, version) {
+        const config = this.versionConfig(resourceType, version);
+        if (!config) {
+            return undefined;
+        }
+        return {
+            version: config.version,
+            phase: config.supportLevel,
+            transitionDate: config.releaseDate,
+            nextPhase: this._determineNextPhase(config.supportLevel),
+            estimatedSunsetDate: config.sunsetDate,
+        };
+    }
+    /**
+     * Finds the best version matching the given constraints
+     *
+     * Selects the optimal version for a resource type based on specified
+     * constraints such as support level, feature requirements, and age limits.
+     *
+     * @param resourceType - The Azure resource type
+     * @param constraints - Version selection constraints
+     * @returns The best matching version, or undefined if no version matches
+     * @internal
+     *
+     * @example
+     * const version = manager._findVersionByConstraints('Microsoft.Resources/resourceGroups', {
+     *   supportLevel: VersionSupportLevel.ACTIVE,
+     *   excludeDeprecated: true,
+     *   notOlderThan: new Date('2024-01-01')
+     * });
+     */
+    _findVersionByConstraints(resourceType, constraints) {
+        const registry = this._resourceRegistry[resourceType];
+        if (!registry) {
+            return undefined;
+        }
+        const candidates = Object.values(registry.versions).filter((config) => {
+            // Check support level constraint
+            if (constraints.supportLevel &&
+                config.supportLevel !== constraints.supportLevel) {
+                return false;
+            }
+            // Check exclude deprecated constraint
+            if (constraints.excludeDeprecated !== false &&
+                config.supportLevel === version_interfaces_1.VersionSupportLevel.DEPRECATED) {
+                return false;
+            }
+            // Check age constraint
+            if (constraints.notOlderThan) {
+                const releaseDate = new Date(config.releaseDate);
+                if (releaseDate < constraints.notOlderThan) {
+                    return false;
+                }
+            }
+            // Check required features (simplified check)
+            if (constraints.requiredFeatures &&
+                constraints.requiredFeatures.length > 0) {
+                // This would need to be implemented based on feature metadata
+                // For now, we assume all versions support all features
+            }
+            return true;
+        });
+        if (candidates.length === 0) {
+            return undefined;
+        }
+        // Sort by release date and return the newest
+        candidates.sort((a, b) => new Date(b.releaseDate).getTime() - new Date(a.releaseDate).getTime());
+        return candidates[0].version;
+    }
+    // =============================================================================
+    // PRIVATE HELPER METHODS
+    // =============================================================================
+    /**
+     * Validates resource type and versions input
+     */
+    _validateResourceTypeInput(resourceType, versions) {
+        if (!resourceType || resourceType.trim().length === 0) {
+            throw new Error("Resource type cannot be empty");
+        }
+        if (!versions || versions.length === 0) {
+            throw new Error("Versions array cannot be empty");
+        }
+    }
+    /**
+     * Validates a single version configuration
+     */
+    _validateVersionConfig(config, resourceType) {
+        if (!config.version || config.version.trim().length === 0) {
+            throw new Error(`Version string cannot be empty for resource type '${resourceType}'`);
+        }
+        if (!config.schema) {
+            throw new Error(`Schema is required for version '${config.version}' of resource type '${resourceType}'`);
+        }
+        if (config.schema.resourceType !== resourceType) {
+            throw new Error(`Schema resource type '${config.schema.resourceType}' does not match registered resource type '${resourceType}'`);
+        }
+        if (config.schema.version !== config.version) {
+            throw new Error(`Schema version '${config.schema.version}' does not match config version '${config.version}'`);
+        }
+        if (!config.supportLevel) {
+            throw new Error(`Support level is required for version '${config.version}' of resource type '${resourceType}'`);
+        }
+        if (!config.releaseDate || config.releaseDate.trim().length === 0) {
+            throw new Error(`Release date is required for version '${config.version}' of resource type '${resourceType}'`);
+        }
+        // Validate date format
+        if (isNaN(new Date(config.releaseDate).getTime())) {
+            throw new Error(`Invalid release date format '${config.releaseDate}' for version '${config.version}' of resource type '${resourceType}'`);
+        }
+    }
+    /**
+     * Collects all breaking changes between two versions
+     */
+    _collectBreakingChanges(resourceType, fromVersion, toVersion) {
+        const registry = this._resourceRegistry[resourceType];
+        if (!registry) {
+            return [];
+        }
+        const allVersions = Object.values(registry.versions).sort((a, b) => new Date(a.releaseDate).getTime() - new Date(b.releaseDate).getTime());
+        const fromIndex = allVersions.findIndex((v) => v.version === fromVersion);
+        const toIndex = allVersions.findIndex((v) => v.version === toVersion);
+        if (fromIndex === -1 || toIndex === -1) {
+            return [];
+        }
+        const breakingChanges = [];
+        // Collect breaking changes from all versions between fromVersion and toVersion
+        for (let i = fromIndex + 1; i <= toIndex; i++) {
+            const versionConfig = allVersions[i];
+            if (versionConfig.breakingChanges) {
+                breakingChanges.push(...versionConfig.breakingChanges);
+            }
+        }
+        return breakingChanges;
+    }
+    /**
+     * Generates migration warnings
+     */
+    _generateMigrationWarnings(fromConfig, toConfig) {
+        const warnings = [];
+        if (fromConfig.supportLevel === version_interfaces_1.VersionSupportLevel.DEPRECATED) {
+            warnings.push(`Source version '${fromConfig.version}' is deprecated. Consider migrating to avoid future compatibility issues.`);
+        }
+        if (toConfig.supportLevel === version_interfaces_1.VersionSupportLevel.DEPRECATED) {
+            warnings.push(`Target version '${toConfig.version}' is deprecated. Consider using a newer version.`);
+        }
+        if (fromConfig.sunsetDate) {
+            const sunsetDate = new Date(fromConfig.sunsetDate);
+            const now = new Date();
+            if (sunsetDate < now) {
+                warnings.push(`Source version '${fromConfig.version}' has reached sunset date (${fromConfig.sunsetDate}). Immediate migration is required.`);
+            }
+        }
+        return warnings;
+    }
+    /**
+     * Calculates migration effort based on breaking changes and version differences
+     */
+    _calculateMigrationEffort(breakingChanges) {
+        if (breakingChanges.length === 0) {
+            return version_interfaces_1.MigrationEffort.LOW;
+        }
+        // Count different types of breaking changes
+        const propertyRemoved = breakingChanges.filter((bc) => bc.changeType === version_interfaces_1.BreakingChangeType.PROPERTY_REMOVED).length;
+        const schemaRestructured = breakingChanges.filter((bc) => bc.changeType === version_interfaces_1.BreakingChangeType.SCHEMA_RESTRUCTURED).length;
+        const propertyTypeChanged = breakingChanges.filter((bc) => bc.changeType === version_interfaces_1.BreakingChangeType.PROPERTY_TYPE_CHANGED).length;
+        // Calculate effort based on breaking change severity
+        if (schemaRestructured > 0 ||
+            propertyRemoved > 3 ||
+            propertyTypeChanged > 3) {
+            return version_interfaces_1.MigrationEffort.BREAKING;
+        }
+        if (propertyRemoved > 1 ||
+            propertyTypeChanged > 1 ||
+            breakingChanges.length > 5) {
+            return version_interfaces_1.MigrationEffort.HIGH;
+        }
+        if (breakingChanges.length > 2) {
+            return version_interfaces_1.MigrationEffort.MEDIUM;
+        }
+        return version_interfaces_1.MigrationEffort.LOW;
+    }
+    /**
+     * Determines if automatic upgrade is possible
+     */
+    _canAutoUpgrade(breakingChanges) {
+        // Automatic upgrade is not possible if there are certain types of breaking changes
+        const blockingChangeTypes = [
+            version_interfaces_1.BreakingChangeType.PROPERTY_REMOVED,
+            version_interfaces_1.BreakingChangeType.SCHEMA_RESTRUCTURED,
+            version_interfaces_1.BreakingChangeType.PROPERTY_TYPE_CHANGED,
+        ];
+        return !breakingChanges.some((bc) => blockingChangeTypes.includes(bc.changeType));
+    }
+    /**
+     * Determines the next phase in the version lifecycle
+     */
+    _determineNextPhase(currentPhase) {
+        switch (currentPhase) {
+            case version_interfaces_1.VersionSupportLevel.ACTIVE:
+                return version_interfaces_1.VersionSupportLevel.MAINTENANCE;
+            case version_interfaces_1.VersionSupportLevel.MAINTENANCE:
+                return version_interfaces_1.VersionSupportLevel.DEPRECATED;
+            case version_interfaces_1.VersionSupportLevel.DEPRECATED:
+                return version_interfaces_1.VersionSupportLevel.SUNSET;
+            default:
+                return undefined;
+        }
+    }
+}
+exports.ApiVersionManager = ApiVersionManager;
+_a = JSII_RTTI_SYMBOL_1;
+ApiVersionManager[_a] = { fqn: "@microsoft/terraform-cdk-constructs.ApiVersionManager", version: "1.0.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-version-manager.js","sourceRoot":"","sources":["../../../../src/core-azure/lib/version-manager/api-version-manager.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ApiVersionManager - A JSII-compliant singleton for managing Azure API versions\n *\n * This class provides centralized version management for Azure resources, including:\n * - Version registry and metadata storage\n * - Version resolution and compatibility analysis\n * - Migration analysis between versions\n * - Thread-safe singleton operations\n *\n * The singleton pattern is implemented in a JSII-compliant way using instance methods\n * rather than static classes to ensure multi-language compatibility.\n *\n * @packageDocumentation\n */\n\nimport {\n  VersionConfig,\n  MigrationAnalysis,\n  BreakingChange,\n  VersionSupportLevel,\n  MigrationEffort,\n  VersionLifecycle,\n  VersionConstraints,\n  BreakingChangeType,\n} from \"./interfaces/version-interfaces\";\n\n/**\n * Registry entry for a resource type containing all version configurations\n */\ninterface ResourceTypeRegistry {\n  readonly resourceType: string;\n  readonly versions: { [version: string]: VersionConfig };\n  readonly latestVersion?: string;\n}\n\n/**\n * ApiVersionManager singleton class for centralized version management\n *\n * This class manages API versions for Azure resources, providing version resolution,\n * compatibility analysis, and migration guidance. It implements a JSII-compliant\n * singleton pattern for thread-safe operations across multiple language bindings.\n *\n * Key Features:\n * - Thread-safe singleton implementation\n * - Version registry management with full lifecycle support\n * - Advanced version resolution with constraint-based selection\n * - Comprehensive migration analysis with effort estimation\n * - Extensive validation and error handling\n *\n * @example\n * const manager = ApiVersionManager.getInstance();\n * manager.registerResourceType('Microsoft.Resources/resourceGroups', versions);\n * const latest = manager.getLatestVersion('Microsoft.Resources/resourceGroups');\n * const analysis = manager.analyzeMigration('Microsoft.Resources/resourceGroups', '2024-01-01', '2024-11-01');\n *\n * @stability stable\n */\nexport class ApiVersionManager {\n  /**\n   * Gets the singleton instance of ApiVersionManager\n   *\n   * This method implements a thread-safe singleton pattern that's compatible\n   * with JSII multi-language bindings. The instance is lazily created on\n   * first access and reused for all subsequent calls.\n   *\n   * @returns The singleton ApiVersionManager instance\n   *\n   * @example\n   * const manager = ApiVersionManager.instance();\n   */\n  public static instance(): ApiVersionManager {\n    if (!ApiVersionManager._instance) {\n      ApiVersionManager._instance = new ApiVersionManager();\n    }\n    return ApiVersionManager._instance;\n  }\n\n  private static _instance: ApiVersionManager | undefined;\n  private readonly _resourceRegistry: {\n    [resourceType: string]: ResourceTypeRegistry;\n  };\n\n  /**\n   * Private constructor to enforce singleton pattern\n   * Initializes the internal registries and data structures\n   */\n  private constructor() {\n    this._resourceRegistry = {};\n  }\n\n  /**\n   * Registers a resource type with its version configurations\n   *\n   * This method stores version metadata for a specific Azure resource type,\n   * including schemas, lifecycle information, and migration data. It validates\n   * the input and maintains internal indexes for efficient lookups.\n   *\n   * @param resourceType - The Azure resource type (e.g., 'Microsoft.Resources/resourceGroups')\n   * @param versions - Array of version configurations for the resource type\n   *\n   * @throws Error if resourceType is empty or versions array is empty\n   * @throws Error if duplicate versions are found in the versions array\n   * @throws Error if version configurations are invalid\n   *\n   * @example\n   * manager.registerResourceType('Microsoft.Resources/resourceGroups', [\n   *   {\n   *     version: '2024-01-01',\n   *     schema: { resourceType: 'Microsoft.Resources/resourceGroups', version: '2024-01-01', properties: {}, required: [] },\n   *     supportLevel: VersionSupportLevel.ACTIVE,\n   *     releaseDate: '2024-01-01'\n   *   }\n   * ]);\n   */\n  public registerResourceType(\n    resourceType: string,\n    versions: VersionConfig[],\n  ): void {\n    this._validateResourceTypeInput(resourceType, versions);\n\n    const versionMap: { [version: string]: VersionConfig } = {};\n    let latestVersion: string | undefined;\n    let latestReleaseDate = new Date(0); // Start with epoch\n\n    // Process and validate each version\n    for (const versionConfig of versions) {\n      this._validateVersionConfig(versionConfig, resourceType);\n\n      // Check for duplicate versions\n      if (versionConfig.version in versionMap) {\n        throw new Error(\n          `Duplicate version '${versionConfig.version}' found for resource type '${resourceType}'`,\n        );\n      }\n\n      versionMap[versionConfig.version] = versionConfig;\n\n      // Track the latest version based on release date and support level\n      const releaseDate = new Date(versionConfig.releaseDate);\n      if (\n        releaseDate >= latestReleaseDate &&\n        versionConfig.supportLevel === VersionSupportLevel.ACTIVE\n      ) {\n        latestVersion = versionConfig.version;\n        latestReleaseDate = releaseDate;\n      }\n    }\n\n    // Store the registry entry\n    const registryEntry: ResourceTypeRegistry = {\n      resourceType,\n      versions: versionMap,\n      latestVersion,\n    };\n\n    this._resourceRegistry[resourceType] = registryEntry;\n  }\n\n  /**\n   * Gets the latest active version for a resource type\n   *\n   * Returns the most recent version with ACTIVE support level. If no active\n   * versions are found, returns the most recent version regardless of support level.\n   *\n   * @param resourceType - The Azure resource type to get the latest version for\n   * @returns The latest version string, or undefined if the resource type is not registered\n   *\n   * @example\n   * const latest = manager.latestVersion('Microsoft.Resources/resourceGroups');\n   * // Returns: \"2024-11-01\"\n   */\n  public latestVersion(resourceType: string): string | undefined {\n    const registry = this._resourceRegistry[resourceType];\n    if (!registry) {\n      return undefined;\n    }\n\n    return registry.latestVersion;\n  }\n\n  /**\n   * Gets the configuration for a specific version of a resource type\n   *\n   * Retrieves the complete version configuration including schema, lifecycle\n   * information, breaking changes, and migration metadata.\n   *\n   * @param resourceType - The Azure resource type\n   * @param version - The specific version to retrieve\n   * @returns The version configuration, or undefined if not found\n   *\n   * @example\n   * const config = manager.versionConfig('Microsoft.Resources/resourceGroups', '2024-01-01');\n   * if (config) {\n   *   console.log(`Support level: ${config.supportLevel}`);\n   *   console.log(`Release date: ${config.releaseDate}`);\n   * }\n   */\n  public versionConfig(\n    resourceType: string,\n    version: string,\n  ): VersionConfig | undefined {\n    const registry = this._resourceRegistry[resourceType];\n    if (!registry) {\n      return undefined;\n    }\n\n    return registry.versions[version];\n  }\n\n  /**\n   * Gets all supported versions for a resource type\n   *\n   * Returns an array of all registered version strings for the specified\n   * resource type, sorted by release date (newest first).\n   *\n   * @param resourceType - The Azure resource type\n   * @returns Array of supported version strings, empty if resource type not registered\n   *\n   * @example\n   * const versions = manager.supportedVersions('Microsoft.Resources/resourceGroups');\n   * // Returns: [\"2024-11-01\", \"2024-01-01\", \"2023-07-01\"]\n   */\n  public supportedVersions(resourceType: string): string[] {\n    const registry = this._resourceRegistry[resourceType];\n    if (!registry) {\n      return [];\n    }\n\n    // Sort versions by release date (newest first)\n    return Object.values(registry.versions)\n      .sort(\n        (a, b) =>\n          new Date(b.releaseDate).getTime() - new Date(a.releaseDate).getTime(),\n      )\n      .map((config) => config.version);\n  }\n\n  /**\n   * Analyzes migration requirements between two versions\n   *\n   * Performs comprehensive analysis of the migration path between source and\n   * target versions, including compatibility assessment, breaking changes\n   * identification, effort estimation, and upgrade feasibility.\n   *\n   * @param resourceType - The Azure resource type\n   * @param fromVersion - The source version to migrate from\n   * @param toVersion - The target version to migrate to\n   * @returns Detailed migration analysis results\n   *\n   * @throws Error if either version is not registered for the resource type\n   * @throws Error if resourceType is not registered\n   *\n   * @example\n   * const analysis = manager.analyzeMigration(\n   *   'Microsoft.Resources/resourceGroups',\n   *   '2024-01-01',\n   *   '2024-11-01'\n   * );\n   *\n   * console.log(`Compatible: ${analysis.compatible}`);\n   * console.log(`Effort: ${analysis.estimatedEffort}`);\n   * console.log(`Breaking changes: ${analysis.breakingChanges.length}`);\n   */\n  public analyzeMigration(\n    resourceType: string,\n    fromVersion: string,\n    toVersion: string,\n  ): MigrationAnalysis {\n    // Validate inputs and get configurations\n    const fromConfig = this.versionConfig(resourceType, fromVersion);\n    const toConfig = this.versionConfig(resourceType, toVersion);\n\n    if (!fromConfig) {\n      throw new Error(\n        `Source version '${fromVersion}' not found for resource type '${resourceType}'`,\n      );\n    }\n\n    if (!toConfig) {\n      throw new Error(\n        `Target version '${toVersion}' not found for resource type '${resourceType}'`,\n      );\n    }\n\n    // Analyze compatibility and changes\n    const allBreakingChanges = this._collectBreakingChanges(\n      resourceType,\n      fromVersion,\n      toVersion,\n    );\n    const compatible = allBreakingChanges.length === 0;\n    const warnings = this._generateMigrationWarnings(fromConfig, toConfig);\n    const estimatedEffort = this._calculateMigrationEffort(allBreakingChanges);\n    const automaticUpgradePossible = this._canAutoUpgrade(allBreakingChanges);\n\n    return {\n      fromVersion,\n      toVersion,\n      compatible,\n      breakingChanges: allBreakingChanges,\n      warnings,\n      estimatedEffort,\n      automaticUpgradePossible,\n    };\n  }\n\n  /**\n   * Validates whether a version is supported for a resource type\n   *\n   * Checks if the specified version is registered and available for use\n   * with the given resource type.\n   *\n   * @param resourceType - The Azure resource type\n   * @param version - The version to validate\n   * @returns True if the version is supported, false otherwise\n   *\n   * @example\n   * if (manager.validateVersionSupport('Microsoft.Resources/resourceGroups', '2024-01-01')) {\n   *   // Version is supported, proceed with resource creation\n   * } else {\n   *   // Handle unsupported version\n   * }\n   */\n  public validateVersionSupport(\n    resourceType: string,\n    version: string,\n  ): boolean {\n    const registry = this._resourceRegistry[resourceType];\n    if (!registry) {\n      return false;\n    }\n\n    return version in registry.versions;\n  }\n\n  /**\n   * Gets all registered resource types\n   *\n   * Returns an array of all Azure resource types that have been registered\n   * with the version manager.\n   *\n   * @returns Array of registered resource type strings\n   *\n   * @example\n   * const resourceTypes = manager.registeredResourceTypes();\n   * // Returns: [\"Microsoft.Resources/resourceGroups\", \"Microsoft.Storage/storageAccounts\", ...]\n   */\n  public registeredResourceTypes(): string[] {\n    return Object.keys(this._resourceRegistry);\n  }\n\n  /**\n   * Gets version lifecycle information for a specific version\n   *\n   * Provides lifecycle metadata including current phase, transition dates,\n   * and projected sunset timeline.\n   *\n   * @param resourceType - The Azure resource type\n   * @param version - The version to get lifecycle information for\n   * @returns Version lifecycle information, or undefined if not found\n   *\n   * @example\n   * const lifecycle = manager.versionLifecycle('Microsoft.Resources/resourceGroups', '2024-01-01');\n   * if (lifecycle) {\n   *   console.log(`Current phase: ${lifecycle.phase}`);\n   *   console.log(`Sunset date: ${lifecycle.estimatedSunsetDate}`);\n   * }\n   */\n  public versionLifecycle(\n    resourceType: string,\n    version: string,\n  ): VersionLifecycle | undefined {\n    const config = this.versionConfig(resourceType, version);\n    if (!config) {\n      return undefined;\n    }\n\n    return {\n      version: config.version,\n      phase: config.supportLevel,\n      transitionDate: config.releaseDate,\n      nextPhase: this._determineNextPhase(config.supportLevel),\n      estimatedSunsetDate: config.sunsetDate,\n    };\n  }\n\n  /**\n   * Finds the best version matching the given constraints\n   *\n   * Selects the optimal version for a resource type based on specified\n   * constraints such as support level, feature requirements, and age limits.\n   *\n   * @param resourceType - The Azure resource type\n   * @param constraints - Version selection constraints\n   * @returns The best matching version, or undefined if no version matches\n   * @internal\n   *\n   * @example\n   * const version = manager._findVersionByConstraints('Microsoft.Resources/resourceGroups', {\n   *   supportLevel: VersionSupportLevel.ACTIVE,\n   *   excludeDeprecated: true,\n   *   notOlderThan: new Date('2024-01-01')\n   * });\n   */\n  public _findVersionByConstraints(\n    resourceType: string,\n    constraints: VersionConstraints,\n  ): string | undefined {\n    const registry = this._resourceRegistry[resourceType];\n    if (!registry) {\n      return undefined;\n    }\n\n    const candidates = Object.values(registry.versions).filter((config) => {\n      // Check support level constraint\n      if (\n        constraints.supportLevel &&\n        config.supportLevel !== constraints.supportLevel\n      ) {\n        return false;\n      }\n\n      // Check exclude deprecated constraint\n      if (\n        constraints.excludeDeprecated !== false &&\n        config.supportLevel === VersionSupportLevel.DEPRECATED\n      ) {\n        return false;\n      }\n\n      // Check age constraint\n      if (constraints.notOlderThan) {\n        const releaseDate = new Date(config.releaseDate);\n        if (releaseDate < constraints.notOlderThan) {\n          return false;\n        }\n      }\n\n      // Check required features (simplified check)\n      if (\n        constraints.requiredFeatures &&\n        constraints.requiredFeatures.length > 0\n      ) {\n        // This would need to be implemented based on feature metadata\n        // For now, we assume all versions support all features\n      }\n\n      return true;\n    });\n\n    if (candidates.length === 0) {\n      return undefined;\n    }\n\n    // Sort by release date and return the newest\n    candidates.sort(\n      (a, b) =>\n        new Date(b.releaseDate).getTime() - new Date(a.releaseDate).getTime(),\n    );\n    return candidates[0].version;\n  }\n\n  // =============================================================================\n  // PRIVATE HELPER METHODS\n  // =============================================================================\n\n  /**\n   * Validates resource type and versions input\n   */\n  private _validateResourceTypeInput(\n    resourceType: string,\n    versions: VersionConfig[],\n  ): void {\n    if (!resourceType || resourceType.trim().length === 0) {\n      throw new Error(\"Resource type cannot be empty\");\n    }\n\n    if (!versions || versions.length === 0) {\n      throw new Error(\"Versions array cannot be empty\");\n    }\n  }\n\n  /**\n   * Validates a single version configuration\n   */\n  private _validateVersionConfig(\n    config: VersionConfig,\n    resourceType: string,\n  ): void {\n    if (!config.version || config.version.trim().length === 0) {\n      throw new Error(\n        `Version string cannot be empty for resource type '${resourceType}'`,\n      );\n    }\n\n    if (!config.schema) {\n      throw new Error(\n        `Schema is required for version '${config.version}' of resource type '${resourceType}'`,\n      );\n    }\n\n    if (config.schema.resourceType !== resourceType) {\n      throw new Error(\n        `Schema resource type '${config.schema.resourceType}' does not match registered resource type '${resourceType}'`,\n      );\n    }\n\n    if (config.schema.version !== config.version) {\n      throw new Error(\n        `Schema version '${config.schema.version}' does not match config version '${config.version}'`,\n      );\n    }\n\n    if (!config.supportLevel) {\n      throw new Error(\n        `Support level is required for version '${config.version}' of resource type '${resourceType}'`,\n      );\n    }\n\n    if (!config.releaseDate || config.releaseDate.trim().length === 0) {\n      throw new Error(\n        `Release date is required for version '${config.version}' of resource type '${resourceType}'`,\n      );\n    }\n\n    // Validate date format\n    if (isNaN(new Date(config.releaseDate).getTime())) {\n      throw new Error(\n        `Invalid release date format '${config.releaseDate}' for version '${config.version}' of resource type '${resourceType}'`,\n      );\n    }\n  }\n\n  /**\n   * Collects all breaking changes between two versions\n   */\n  private _collectBreakingChanges(\n    resourceType: string,\n    fromVersion: string,\n    toVersion: string,\n  ): BreakingChange[] {\n    const registry = this._resourceRegistry[resourceType];\n    if (!registry) {\n      return [];\n    }\n\n    const allVersions = Object.values(registry.versions).sort(\n      (a, b) =>\n        new Date(a.releaseDate).getTime() - new Date(b.releaseDate).getTime(),\n    );\n\n    const fromIndex = allVersions.findIndex((v) => v.version === fromVersion);\n    const toIndex = allVersions.findIndex((v) => v.version === toVersion);\n\n    if (fromIndex === -1 || toIndex === -1) {\n      return [];\n    }\n\n    const breakingChanges: BreakingChange[] = [];\n\n    // Collect breaking changes from all versions between fromVersion and toVersion\n    for (let i = fromIndex + 1; i <= toIndex; i++) {\n      const versionConfig = allVersions[i];\n      if (versionConfig.breakingChanges) {\n        breakingChanges.push(...versionConfig.breakingChanges);\n      }\n    }\n\n    return breakingChanges;\n  }\n\n  /**\n   * Generates migration warnings\n   */\n  private _generateMigrationWarnings(\n    fromConfig: VersionConfig,\n    toConfig: VersionConfig,\n  ): string[] {\n    const warnings: string[] = [];\n\n    if (fromConfig.supportLevel === VersionSupportLevel.DEPRECATED) {\n      warnings.push(\n        `Source version '${fromConfig.version}' is deprecated. Consider migrating to avoid future compatibility issues.`,\n      );\n    }\n\n    if (toConfig.supportLevel === VersionSupportLevel.DEPRECATED) {\n      warnings.push(\n        `Target version '${toConfig.version}' is deprecated. Consider using a newer version.`,\n      );\n    }\n\n    if (fromConfig.sunsetDate) {\n      const sunsetDate = new Date(fromConfig.sunsetDate);\n      const now = new Date();\n      if (sunsetDate < now) {\n        warnings.push(\n          `Source version '${fromConfig.version}' has reached sunset date (${fromConfig.sunsetDate}). Immediate migration is required.`,\n        );\n      }\n    }\n\n    return warnings;\n  }\n\n  /**\n   * Calculates migration effort based on breaking changes and version differences\n   */\n  private _calculateMigrationEffort(breakingChanges: BreakingChange[]): string {\n    if (breakingChanges.length === 0) {\n      return MigrationEffort.LOW;\n    }\n\n    // Count different types of breaking changes\n    const propertyRemoved = breakingChanges.filter(\n      (bc) => bc.changeType === BreakingChangeType.PROPERTY_REMOVED,\n    ).length;\n    const schemaRestructured = breakingChanges.filter(\n      (bc) => bc.changeType === BreakingChangeType.SCHEMA_RESTRUCTURED,\n    ).length;\n    const propertyTypeChanged = breakingChanges.filter(\n      (bc) => bc.changeType === BreakingChangeType.PROPERTY_TYPE_CHANGED,\n    ).length;\n\n    // Calculate effort based on breaking change severity\n    if (\n      schemaRestructured > 0 ||\n      propertyRemoved > 3 ||\n      propertyTypeChanged > 3\n    ) {\n      return MigrationEffort.BREAKING;\n    }\n\n    if (\n      propertyRemoved > 1 ||\n      propertyTypeChanged > 1 ||\n      breakingChanges.length > 5\n    ) {\n      return MigrationEffort.HIGH;\n    }\n\n    if (breakingChanges.length > 2) {\n      return MigrationEffort.MEDIUM;\n    }\n\n    return MigrationEffort.LOW;\n  }\n\n  /**\n   * Determines if automatic upgrade is possible\n   */\n  private _canAutoUpgrade(breakingChanges: BreakingChange[]): boolean {\n    // Automatic upgrade is not possible if there are certain types of breaking changes\n    const blockingChangeTypes = [\n      BreakingChangeType.PROPERTY_REMOVED,\n      BreakingChangeType.SCHEMA_RESTRUCTURED,\n      BreakingChangeType.PROPERTY_TYPE_CHANGED,\n    ];\n\n    return !breakingChanges.some((bc) =>\n      blockingChangeTypes.includes(bc.changeType as any),\n    );\n  }\n\n  /**\n   * Determines the next phase in the version lifecycle\n   */\n  private _determineNextPhase(currentPhase: string): string | undefined {\n    switch (currentPhase) {\n      case VersionSupportLevel.ACTIVE:\n        return VersionSupportLevel.MAINTENANCE;\n      case VersionSupportLevel.MAINTENANCE:\n        return VersionSupportLevel.DEPRECATED;\n      case VersionSupportLevel.DEPRECATED:\n        return VersionSupportLevel.SUNSET;\n      default:\n        return undefined;\n    }\n  }\n}\n"]}

package/lib/core-azure/lib/version-manager/api-version-manager.spec.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Comprehensive tests for ApiVersionManager - Version management framework
+ *
+ * This test suite validates all functionality of the ApiVersionManager singleton,
+ * including version registration, resolution, migration analysis, and lifecycle management.
+ */
+export {};