@microsoft/terraform-cdk-constructs 1.2.0 → 1.3.0

package/lib/core-azure/lib/azapi/resource-schema-validator.d.ts

@@ -0,0 +1,118 @@
+/**
+ * ResourceSchemaValidator - Helper class for schema validation
+ *
+ * This helper class extracts validation logic from AzapiResource to follow
+ * the Single Responsibility Principle. It handles property validation against
+ * API schemas and provides detailed error reporting.
+ *
+ * @internal
+ * @packageDocumentation
+ */
+import { ApiSchema, ValidationResult } from "../version-manager/interfaces/version-interfaces";
+/**
+ * Helper class for validating resource properties against API schemas
+ *
+ * This class encapsulates all validation-related operations including:
+ * - Schema-based property validation
+ * - Default value application
+ * - Validation error formatting
+ * - Integration with SchemaMapper
+ *
+ * @internal
+ */
+export declare class ResourceSchemaValidator {
+    private readonly _schema;
+    private readonly _schemaMapper;
+    /**
+     * Creates a new ResourceSchemaValidator instance
+     *
+     * @param schema - The API schema to validate against
+     */
+    constructor(schema: ApiSchema);
+    /**
+     * Validates properties against the configured schema
+     *
+     * This method performs comprehensive validation including:
+     * - Required property checks
+     * - Type validation
+     * - Custom validation rules
+     * - Deprecation warnings
+     *
+     * @param properties - The properties to validate
+     * @returns Detailed validation results with errors and warnings
+     */
+    validateProps(properties: any): ValidationResult;
+    /**
+     * Validates the schema structure itself
+     *
+     * This method checks if the schema is properly configured and has all
+     * required fields for validation to work correctly.
+     *
+     * @returns Validation result indicating if schema is valid
+     */
+    validateSchema(): ValidationResult;
+    /**
+     * Applies default values to properties based on schema definitions
+     *
+     * This method injects default values for properties that are not provided
+     * but have defaults defined in the schema.
+     *
+     * @param properties - The properties to apply defaults to
+     * @returns New properties object with default values applied
+     */
+    applyDefaults(properties: any): any;
+    /**
+     * Formats validation errors into user-friendly messages
+     *
+     * This method takes a validation result and formats the errors
+     * into clear, actionable error messages.
+     *
+     * @param validationResult - The validation result to format
+     * @returns Array of formatted error messages
+     */
+    formatValidationErrors(validationResult: ValidationResult): string[];
+    /**
+     * Gets the schema this validator is configured for
+     *
+     * @returns The API schema being used for validation
+     */
+    get schema(): ApiSchema;
+    /**
+     * Gets the resource type from the schema
+     *
+     * @returns The Azure resource type string
+     */
+    get resourceType(): string;
+    /**
+     * Gets the API version from the schema
+     *
+     * @returns The API version string
+     */
+    get version(): string;
+    /**
+     * Checks if a specific property is required
+     *
+     * @param propertyName - The name of the property to check
+     * @returns True if the property is required, false otherwise
+     */
+    isPropertyRequired(propertyName: string): boolean;
+    /**
+     * Checks if a specific property is deprecated
+     *
+     * @param propertyName - The name of the property to check
+     * @returns True if the property is deprecated, false otherwise
+     */
+    isPropertyDeprecated(propertyName: string): boolean;
+    /**
+     * Gets the list of all required properties
+     *
+     * @returns Array of required property names
+     */
+    getRequiredProperties(): string[];
+    /**
+     * Gets the list of all deprecated properties
+     *
+     * @returns Array of deprecated property names
+     */
+    getDeprecatedProperties(): string[];
+}

package/lib/core-azure/lib/azapi/resource-schema-validator.js

@@ -0,0 +1,236 @@
+"use strict";
+/**
+ * ResourceSchemaValidator - Helper class for schema validation
+ *
+ * This helper class extracts validation logic from AzapiResource to follow
+ * the Single Responsibility Principle. It handles property validation against
+ * API schemas and provides detailed error reporting.
+ *
+ * @internal
+ * @packageDocumentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceSchemaValidator = void 0;
+const schema_mapper_1 = require("./schema-mapper/schema-mapper");
+/**
+ * Helper class for validating resource properties against API schemas
+ *
+ * This class encapsulates all validation-related operations including:
+ * - Schema-based property validation
+ * - Default value application
+ * - Validation error formatting
+ * - Integration with SchemaMapper
+ *
+ * @internal
+ */
+class ResourceSchemaValidator {
+    /**
+     * Creates a new ResourceSchemaValidator instance
+     *
+     * @param schema - The API schema to validate against
+     */
+    constructor(schema) {
+        if (!schema) {
+            throw new Error("Schema cannot be undefined or null");
+        }
+        if (!schema.resourceType || schema.resourceType.trim().length === 0) {
+            throw new Error("Schema must have a valid resourceType");
+        }
+        if (!schema.version || schema.version.trim().length === 0) {
+            throw new Error("Schema must have a valid version");
+        }
+        this._schema = schema;
+        this._schemaMapper = schema_mapper_1.SchemaMapper.create(schema);
+    }
+    /**
+     * Validates properties against the configured schema
+     *
+     * This method performs comprehensive validation including:
+     * - Required property checks
+     * - Type validation
+     * - Custom validation rules
+     * - Deprecation warnings
+     *
+     * @param properties - The properties to validate
+     * @returns Detailed validation results with errors and warnings
+     */
+    validateProps(properties) {
+        if (!properties) {
+            return {
+                valid: false,
+                errors: ["Properties cannot be undefined or null"],
+                warnings: [],
+            };
+        }
+        try {
+            return this._schemaMapper.validateProperties(properties);
+        }
+        catch (error) {
+            return {
+                valid: false,
+                errors: [
+                    `Validation failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+                ],
+                warnings: [],
+            };
+        }
+    }
+    /**
+     * Validates the schema structure itself
+     *
+     * This method checks if the schema is properly configured and has all
+     * required fields for validation to work correctly.
+     *
+     * @returns Validation result indicating if schema is valid
+     */
+    validateSchema() {
+        const errors = [];
+        const warnings = [];
+        // Check for required schema fields
+        if (!this._schema.resourceType) {
+            errors.push("Schema is missing resourceType");
+        }
+        if (!this._schema.version) {
+            errors.push("Schema is missing version");
+        }
+        if (!this._schema.properties) {
+            errors.push("Schema is missing properties definition");
+        }
+        if (!this._schema.required) {
+            errors.push("Schema is missing required properties array");
+        }
+        // Check for potential issues
+        if (this._schema.required &&
+            Array.isArray(this._schema.required) &&
+            this._schema.required.length === 0) {
+            warnings.push("Schema has no required properties defined");
+        }
+        if (this._schema.properties &&
+            Object.keys(this._schema.properties).length === 0) {
+            warnings.push("Schema has no properties defined");
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+            warnings,
+        };
+    }
+    /**
+     * Applies default values to properties based on schema definitions
+     *
+     * This method injects default values for properties that are not provided
+     * but have defaults defined in the schema.
+     *
+     * @param properties - The properties to apply defaults to
+     * @returns New properties object with default values applied
+     */
+    applyDefaults(properties) {
+        if (!properties) {
+            properties = {};
+        }
+        try {
+            return this._schemaMapper.applyDefaults(properties);
+        }
+        catch (error) {
+            throw new Error(`Failed to apply defaults: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    }
+    /**
+     * Formats validation errors into user-friendly messages
+     *
+     * This method takes a validation result and formats the errors
+     * into clear, actionable error messages.
+     *
+     * @param validationResult - The validation result to format
+     * @returns Array of formatted error messages
+     */
+    formatValidationErrors(validationResult) {
+        const formattedErrors = [];
+        // Add general errors
+        formattedErrors.push(...validationResult.errors);
+        // Add property-specific errors with context
+        if (validationResult.propertyErrors) {
+            for (const [property, errors] of Object.entries(validationResult.propertyErrors)) {
+                for (const error of errors) {
+                    formattedErrors.push(`[${property}] ${error}`);
+                }
+            }
+        }
+        return formattedErrors;
+    }
+    /**
+     * Gets the schema this validator is configured for
+     *
+     * @returns The API schema being used for validation
+     */
+    get schema() {
+        return this._schema;
+    }
+    /**
+     * Gets the resource type from the schema
+     *
+     * @returns The Azure resource type string
+     */
+    get resourceType() {
+        return this._schema.resourceType;
+    }
+    /**
+     * Gets the API version from the schema
+     *
+     * @returns The API version string
+     */
+    get version() {
+        return this._schema.version;
+    }
+    /**
+     * Checks if a specific property is required
+     *
+     * @param propertyName - The name of the property to check
+     * @returns True if the property is required, false otherwise
+     */
+    isPropertyRequired(propertyName) {
+        if (!this._schema.required || !Array.isArray(this._schema.required)) {
+            return false;
+        }
+        return this._schema.required.includes(propertyName);
+    }
+    /**
+     * Checks if a specific property is deprecated
+     *
+     * @param propertyName - The name of the property to check
+     * @returns True if the property is deprecated, false otherwise
+     */
+    isPropertyDeprecated(propertyName) {
+        if (!this._schema.properties) {
+            return false;
+        }
+        const propDef = this._schema.properties[propertyName];
+        return propDef ? propDef.deprecated === true : false;
+    }
+    /**
+     * Gets the list of all required properties
+     *
+     * @returns Array of required property names
+     */
+    getRequiredProperties() {
+        if (!this._schema.required || !Array.isArray(this._schema.required)) {
+            return [];
+        }
+        return [...this._schema.required];
+    }
+    /**
+     * Gets the list of all deprecated properties
+     *
+     * @returns Array of deprecated property names
+     */
+    getDeprecatedProperties() {
+        if (!this._schema.properties) {
+            return [];
+        }
+        return Object.entries(this._schema.properties)
+            .filter(([_, propDef]) => propDef.deprecated === true)
+            .map(([propName]) => propName);
+    }
+}
+exports.ResourceSchemaValidator = ResourceSchemaValidator;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resource-schema-validator.js","sourceRoot":"","sources":["../../../../src/core-azure/lib/azapi/resource-schema-validator.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ResourceSchemaValidator - Helper class for schema validation\n *\n * This helper class extracts validation logic from AzapiResource to follow\n * the Single Responsibility Principle. It handles property validation against\n * API schemas and provides detailed error reporting.\n *\n * @internal\n * @packageDocumentation\n */\n\nimport { SchemaMapper } from \"./schema-mapper/schema-mapper\";\nimport {\n  ApiSchema,\n  ValidationResult,\n} from \"../version-manager/interfaces/version-interfaces\";\n\n/**\n * Helper class for validating resource properties against API schemas\n *\n * This class encapsulates all validation-related operations including:\n * - Schema-based property validation\n * - Default value application\n * - Validation error formatting\n * - Integration with SchemaMapper\n *\n * @internal\n */\nexport class ResourceSchemaValidator {\n  private readonly _schema: ApiSchema;\n  private readonly _schemaMapper: SchemaMapper;\n\n  /**\n   * Creates a new ResourceSchemaValidator instance\n   *\n   * @param schema - The API schema to validate against\n   */\n  constructor(schema: ApiSchema) {\n    if (!schema) {\n      throw new Error(\"Schema cannot be undefined or null\");\n    }\n\n    if (!schema.resourceType || schema.resourceType.trim().length === 0) {\n      throw new Error(\"Schema must have a valid resourceType\");\n    }\n\n    if (!schema.version || schema.version.trim().length === 0) {\n      throw new Error(\"Schema must have a valid version\");\n    }\n\n    this._schema = schema;\n    this._schemaMapper = SchemaMapper.create(schema);\n  }\n\n  /**\n   * Validates properties against the configured schema\n   *\n   * This method performs comprehensive validation including:\n   * - Required property checks\n   * - Type validation\n   * - Custom validation rules\n   * - Deprecation warnings\n   *\n   * @param properties - The properties to validate\n   * @returns Detailed validation results with errors and warnings\n   */\n  public validateProps(properties: any): ValidationResult {\n    if (!properties) {\n      return {\n        valid: false,\n        errors: [\"Properties cannot be undefined or null\"],\n        warnings: [],\n      };\n    }\n\n    try {\n      return this._schemaMapper.validateProperties(properties);\n    } catch (error) {\n      return {\n        valid: false,\n        errors: [\n          `Validation failed: ${error instanceof Error ? error.message : \"Unknown error\"}`,\n        ],\n        warnings: [],\n      };\n    }\n  }\n\n  /**\n   * Validates the schema structure itself\n   *\n   * This method checks if the schema is properly configured and has all\n   * required fields for validation to work correctly.\n   *\n   * @returns Validation result indicating if schema is valid\n   */\n  public validateSchema(): ValidationResult {\n    const errors: string[] = [];\n    const warnings: string[] = [];\n\n    // Check for required schema fields\n    if (!this._schema.resourceType) {\n      errors.push(\"Schema is missing resourceType\");\n    }\n\n    if (!this._schema.version) {\n      errors.push(\"Schema is missing version\");\n    }\n\n    if (!this._schema.properties) {\n      errors.push(\"Schema is missing properties definition\");\n    }\n\n    if (!this._schema.required) {\n      errors.push(\"Schema is missing required properties array\");\n    }\n\n    // Check for potential issues\n    if (\n      this._schema.required &&\n      Array.isArray(this._schema.required) &&\n      this._schema.required.length === 0\n    ) {\n      warnings.push(\"Schema has no required properties defined\");\n    }\n\n    if (\n      this._schema.properties &&\n      Object.keys(this._schema.properties).length === 0\n    ) {\n      warnings.push(\"Schema has no properties defined\");\n    }\n\n    return {\n      valid: errors.length === 0,\n      errors,\n      warnings,\n    };\n  }\n\n  /**\n   * Applies default values to properties based on schema definitions\n   *\n   * This method injects default values for properties that are not provided\n   * but have defaults defined in the schema.\n   *\n   * @param properties - The properties to apply defaults to\n   * @returns New properties object with default values applied\n   */\n  public applyDefaults(properties: any): any {\n    if (!properties) {\n      properties = {};\n    }\n\n    try {\n      return this._schemaMapper.applyDefaults(properties);\n    } catch (error) {\n      throw new Error(\n        `Failed to apply defaults: ${error instanceof Error ? error.message : \"Unknown error\"}`,\n      );\n    }\n  }\n\n  /**\n   * Formats validation errors into user-friendly messages\n   *\n   * This method takes a validation result and formats the errors\n   * into clear, actionable error messages.\n   *\n   * @param validationResult - The validation result to format\n   * @returns Array of formatted error messages\n   */\n  public formatValidationErrors(validationResult: ValidationResult): string[] {\n    const formattedErrors: string[] = [];\n\n    // Add general errors\n    formattedErrors.push(...validationResult.errors);\n\n    // Add property-specific errors with context\n    if (validationResult.propertyErrors) {\n      for (const [property, errors] of Object.entries(\n        validationResult.propertyErrors,\n      )) {\n        for (const error of errors) {\n          formattedErrors.push(`[${property}] ${error}`);\n        }\n      }\n    }\n\n    return formattedErrors;\n  }\n\n  /**\n   * Gets the schema this validator is configured for\n   *\n   * @returns The API schema being used for validation\n   */\n  public get schema(): ApiSchema {\n    return this._schema;\n  }\n\n  /**\n   * Gets the resource type from the schema\n   *\n   * @returns The Azure resource type string\n   */\n  public get resourceType(): string {\n    return this._schema.resourceType;\n  }\n\n  /**\n   * Gets the API version from the schema\n   *\n   * @returns The API version string\n   */\n  public get version(): string {\n    return this._schema.version;\n  }\n\n  /**\n   * Checks if a specific property is required\n   *\n   * @param propertyName - The name of the property to check\n   * @returns True if the property is required, false otherwise\n   */\n  public isPropertyRequired(propertyName: string): boolean {\n    if (!this._schema.required || !Array.isArray(this._schema.required)) {\n      return false;\n    }\n\n    return this._schema.required.includes(propertyName);\n  }\n\n  /**\n   * Checks if a specific property is deprecated\n   *\n   * @param propertyName - The name of the property to check\n   * @returns True if the property is deprecated, false otherwise\n   */\n  public isPropertyDeprecated(propertyName: string): boolean {\n    if (!this._schema.properties) {\n      return false;\n    }\n\n    const propDef = this._schema.properties[propertyName];\n    return propDef ? propDef.deprecated === true : false;\n  }\n\n  /**\n   * Gets the list of all required properties\n   *\n   * @returns Array of required property names\n   */\n  public getRequiredProperties(): string[] {\n    if (!this._schema.required || !Array.isArray(this._schema.required)) {\n      return [];\n    }\n\n    return [...this._schema.required];\n  }\n\n  /**\n   * Gets the list of all deprecated properties\n   *\n   * @returns Array of deprecated property names\n   */\n  public getDeprecatedProperties(): string[] {\n    if (!this._schema.properties) {\n      return [];\n    }\n\n    return Object.entries(this._schema.properties)\n      .filter(([_, propDef]) => propDef.deprecated === true)\n      .map(([propName]) => propName);\n  }\n}\n"]}

package/lib/core-azure/lib/azapi/resource-version-manager.d.ts

@@ -0,0 +1,103 @@
+/**
+ * ResourceVersionManager - Helper class for managing API version resolution
+ *
+ * This helper class extracts version management logic from AzapiResource to follow
+ * the Single Responsibility Principle. It handles version resolution, validation,
+ * and configuration retrieval.
+ *
+ * @internal
+ * @packageDocumentation
+ */
+import { ApiSchema, VersionConfig } from "../version-manager/interfaces/version-interfaces";
+/**
+ * Helper class for managing API version resolution and configuration
+ *
+ * This class encapsulates all version-related operations including:
+ * - API version resolution (explicit or automatic)
+ * - Version validation against registered versions
+ * - Schema and configuration retrieval
+ * - Latest version resolution
+ *
+ * @internal
+ */
+export declare class ResourceVersionManager {
+    private readonly _apiVersionManager;
+    private readonly _resourceType;
+    private readonly _defaultVersion;
+    /**
+     * Creates a new ResourceVersionManager instance
+     *
+     * @param resourceType - The Azure resource type (e.g., "Microsoft.Resources/resourceGroups")
+     * @param defaultVersion - The default version to use as fallback
+     */
+    constructor(resourceType: string, defaultVersion: string);
+    /**
+     * Resolves the API version to use for a resource instance
+     *
+     * This method implements the version resolution logic:
+     * 1. If explicitVersion is provided, validate and use it
+     * 2. Otherwise, try to get the latest version from ApiVersionManager
+     * 3. If no versions registered, fall back to defaultVersion
+     *
+     * @param explicitVersion - Optional explicit version specified by user
+     * @returns The resolved API version string
+     * @throws Error if explicit version is provided but not supported
+     */
+    resolveApiVersion(explicitVersion?: string): string;
+    /**
+     * Retrieves the version configuration for a specific version
+     *
+     * @param version - The version to retrieve configuration for
+     * @returns The version configuration, or undefined if not found
+     */
+    versionConfig(version: string): VersionConfig | undefined;
+    /**
+     * Retrieves the API schema for a specific version
+     *
+     * @param version - The version to retrieve schema for
+     * @returns The API schema for the version
+     * @throws Error if version configuration or schema cannot be found
+     */
+    schemaForVersion(version: string): ApiSchema;
+    /**
+     * Validates whether a version is supported for the resource type
+     *
+     * @param version - The version to validate
+     * @returns True if the version is supported, false otherwise
+     */
+    validateVersion(version: string): boolean;
+    /**
+     * Retrieves the latest available version for the resource type
+     *
+     * @returns The latest version string, or undefined if none found
+     */
+    latestVersion(): string | undefined;
+    /**
+     * Retrieves all supported versions for the resource type
+     *
+     * @returns Array of supported version strings, sorted by release date (newest first)
+     */
+    supportedVersions(): string[];
+    /**
+     * Checks if the version is deprecated
+     *
+     * @param version - The version to check
+     * @returns True if the version is deprecated or sunset, false otherwise
+     */
+    isDeprecated(version: string): boolean;
+    /**
+     * Checks if the version has reached sunset
+     *
+     * @param version - The version to check
+     * @returns True if the version has reached sunset, false otherwise
+     */
+    isSunset(version: string): boolean;
+    /**
+     * The resource type this manager is configured for
+     */
+    get resourceType(): string;
+    /**
+     * The default version configured for this manager
+     */
+    get defaultVersion(): string;
+}

package/lib/core-azure/lib/azapi/resource-version-manager.js

@@ -0,0 +1,168 @@
+"use strict";
+/**
+ * ResourceVersionManager - Helper class for managing API version resolution
+ *
+ * This helper class extracts version management logic from AzapiResource to follow
+ * the Single Responsibility Principle. It handles version resolution, validation,
+ * and configuration retrieval.
+ *
+ * @internal
+ * @packageDocumentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceVersionManager = void 0;
+const api_version_manager_1 = require("../version-manager/api-version-manager");
+const version_interfaces_1 = require("../version-manager/interfaces/version-interfaces");
+/**
+ * Helper class for managing API version resolution and configuration
+ *
+ * This class encapsulates all version-related operations including:
+ * - API version resolution (explicit or automatic)
+ * - Version validation against registered versions
+ * - Schema and configuration retrieval
+ * - Latest version resolution
+ *
+ * @internal
+ */
+class ResourceVersionManager {
+    /**
+     * Creates a new ResourceVersionManager instance
+     *
+     * @param resourceType - The Azure resource type (e.g., "Microsoft.Resources/resourceGroups")
+     * @param defaultVersion - The default version to use as fallback
+     */
+    constructor(resourceType, defaultVersion) {
+        if (!resourceType || resourceType.trim().length === 0) {
+            throw new Error("Resource type cannot be empty");
+        }
+        if (!defaultVersion || defaultVersion.trim().length === 0) {
+            throw new Error("Default version cannot be empty");
+        }
+        this._resourceType = resourceType;
+        this._defaultVersion = defaultVersion;
+        this._apiVersionManager = api_version_manager_1.ApiVersionManager.instance();
+    }
+    /**
+     * Resolves the API version to use for a resource instance
+     *
+     * This method implements the version resolution logic:
+     * 1. If explicitVersion is provided, validate and use it
+     * 2. Otherwise, try to get the latest version from ApiVersionManager
+     * 3. If no versions registered, fall back to defaultVersion
+     *
+     * @param explicitVersion - Optional explicit version specified by user
+     * @returns The resolved API version string
+     * @throws Error if explicit version is provided but not supported
+     */
+    resolveApiVersion(explicitVersion) {
+        if (explicitVersion) {
+            // Validate that the explicit version is supported
+            if (!this.validateVersion(explicitVersion)) {
+                const supportedVersions = this.supportedVersions();
+                throw new Error(`Unsupported API version '${explicitVersion}' for resource type '${this._resourceType}'. ` +
+                    `Supported versions: ${supportedVersions.join(", ")}`);
+            }
+            return explicitVersion;
+        }
+        // Try to get the latest version from the manager
+        const latestVersion = this.latestVersion();
+        if (latestVersion) {
+            return latestVersion;
+        }
+        // Fall back to the default version
+        console.warn(`No versions registered for ${this._resourceType}. ` +
+            `Using default version: ${this._defaultVersion}. ` +
+            `Consider registering versions with ApiVersionManager for better version management.`);
+        return this._defaultVersion;
+    }
+    /**
+     * Retrieves the version configuration for a specific version
+     *
+     * @param version - The version to retrieve configuration for
+     * @returns The version configuration, or undefined if not found
+     */
+    versionConfig(version) {
+        return this._apiVersionManager.versionConfig(this._resourceType, version);
+    }
+    /**
+     * Retrieves the API schema for a specific version
+     *
+     * @param version - The version to retrieve schema for
+     * @returns The API schema for the version
+     * @throws Error if version configuration or schema cannot be found
+     */
+    schemaForVersion(version) {
+        const versionConfig = this.versionConfig(version);
+        if (!versionConfig) {
+            throw new Error(`Cannot resolve schema: version configuration not found for ` +
+                `${this._resourceType}@${version}`);
+        }
+        return versionConfig.schema;
+    }
+    /**
+     * Validates whether a version is supported for the resource type
+     *
+     * @param version - The version to validate
+     * @returns True if the version is supported, false otherwise
+     */
+    validateVersion(version) {
+        return this._apiVersionManager.validateVersionSupport(this._resourceType, version);
+    }
+    /**
+     * Retrieves the latest available version for the resource type
+     *
+     * @returns The latest version string, or undefined if none found
+     */
+    latestVersion() {
+        return this._apiVersionManager.latestVersion(this._resourceType);
+    }
+    /**
+     * Retrieves all supported versions for the resource type
+     *
+     * @returns Array of supported version strings, sorted by release date (newest first)
+     */
+    supportedVersions() {
+        return this._apiVersionManager.supportedVersions(this._resourceType);
+    }
+    /**
+     * Checks if the version is deprecated
+     *
+     * @param version - The version to check
+     * @returns True if the version is deprecated or sunset, false otherwise
+     */
+    isDeprecated(version) {
+        const config = this.versionConfig(version);
+        if (!config) {
+            return false;
+        }
+        return (config.supportLevel === version_interfaces_1.VersionSupportLevel.DEPRECATED ||
+            config.supportLevel === version_interfaces_1.VersionSupportLevel.SUNSET);
+    }
+    /**
+     * Checks if the version has reached sunset
+     *
+     * @param version - The version to check
+     * @returns True if the version has reached sunset, false otherwise
+     */
+    isSunset(version) {
+        const config = this.versionConfig(version);
+        if (!config) {
+            return false;
+        }
+        return config.supportLevel === version_interfaces_1.VersionSupportLevel.SUNSET;
+    }
+    /**
+     * The resource type this manager is configured for
+     */
+    get resourceType() {
+        return this._resourceType;
+    }
+    /**
+     * The default version configured for this manager
+     */
+    get defaultVersion() {
+        return this._defaultVersion;
+    }
+}
+exports.ResourceVersionManager = ResourceVersionManager;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resource-version-manager.js","sourceRoot":"","sources":["../../../../src/core-azure/lib/azapi/resource-version-manager.ts"],"names":[],"mappings":";AAAA;;;;;;;;;GASG;;;AAEH,gFAA2E;AAC3E,yFAI0D;AAE1D;;;;;;;;;;GAUG;AACH,MAAa,sBAAsB;IAKjC;;;;;OAKG;IACH,YAAY,YAAoB,EAAE,cAAsB;QACtD,IAAI,CAAC,YAAY,IAAI,YAAY,CAAC,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACtD,MAAM,IAAI,KAAK,CAAC,+BAA+B,CAAC,CAAC;QACnD,CAAC;QAED,IAAI,CAAC,cAAc,IAAI,cAAc,CAAC,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC1D,MAAM,IAAI,KAAK,CAAC,iCAAiC,CAAC,CAAC;QACrD,CAAC;QAED,IAAI,CAAC,aAAa,GAAG,YAAY,CAAC;QAClC,IAAI,CAAC,eAAe,GAAG,cAAc,CAAC;QACtC,IAAI,CAAC,kBAAkB,GAAG,uCAAiB,CAAC,QAAQ,EAAE,CAAC;IACzD,CAAC;IAED;;;;;;;;;;;OAWG;IACI,iBAAiB,CAAC,eAAwB;QAC/C,IAAI,eAAe,EAAE,CAAC;YACpB,kDAAkD;YAClD,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,eAAe,CAAC,EAAE,CAAC;gBAC3C,MAAM,iBAAiB,GAAG,IAAI,CAAC,iBAAiB,EAAE,CAAC;gBACnD,MAAM,IAAI,KAAK,CACb,4BAA4B,eAAe,wBAAwB,IAAI,CAAC,aAAa,KAAK;oBACxF,uBAAuB,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CACxD,CAAC;YACJ,CAAC;YACD,OAAO,eAAe,CAAC;QACzB,CAAC;QAED,iDAAiD;QACjD,MAAM,aAAa,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC;QAC3C,IAAI,aAAa,EAAE,CAAC;YAClB,OAAO,aAAa,CAAC;QACvB,CAAC;QAED,mCAAmC;QACnC,OAAO,CAAC,IAAI,CACV,8BAA8B,IAAI,CAAC,aAAa,IAAI;YAClD,0BAA0B,IAAI,CAAC,eAAe,IAAI;YAClD,qFAAqF,CACxF,CAAC;QAEF,OAAO,IAAI,CAAC,eAAe,CAAC;IAC9B,CAAC;IAED;;;;;OAKG;IACI,aAAa,CAAC,OAAe;QAClC,OAAO,IAAI,CAAC,kBAAkB,CAAC,aAAa,CAAC,IAAI,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC;IAC5E,CAAC;IAED;;;;;;OAMG;IACI,gBAAgB,CAAC,OAAe;QACrC,MAAM,aAAa,GAAG,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;QAElD,IAAI,CAAC,aAAa,EAAE,CAAC;YACnB,MAAM,IAAI,KAAK,CACb,6DAA6D;gBAC3D,GAAG,IAAI,CAAC,aAAa,IAAI,OAAO,EAAE,CACrC,CAAC;QACJ,CAAC;QAED,OAAO,aAAa,CAAC,MAAM,CAAC;IAC9B,CAAC;IAED;;;;;OAKG;IACI,eAAe,CAAC,OAAe;QACpC,OAAO,IAAI,CAAC,kBAAkB,CAAC,sBAAsB,CACnD,IAAI,CAAC,aAAa,EAClB,OAAO,CACR,CAAC;IACJ,CAAC;IAED;;;;OAIG;IACI,aAAa;QAClB,OAAO,IAAI,CAAC,kBAAkB,CAAC,aAAa,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;IACnE,CAAC;IAED;;;;OAIG;IACI,iBAAiB;QACtB,OAAO,IAAI,CAAC,kBAAkB,CAAC,iBAAiB,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;IACvE,CAAC;IAED;;;;;OAKG;IACI,YAAY,CAAC,OAAe;QACjC,MAAM,MAAM,GAAG,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;QAC3C,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,OAAO,KAAK,CAAC;QACf,CAAC;QAED,OAAO,CACL,MAAM,CAAC,YAAY,KAAK,wCAAmB,CAAC,UAAU;YACtD,MAAM,CAAC,YAAY,KAAK,wCAAmB,CAAC,MAAM,CACnD,CAAC;IACJ,CAAC;IAED;;;;;OAKG;IACI,QAAQ,CAAC,OAAe;QAC7B,MAAM,MAAM,GAAG,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;QAC3C,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,OAAO,KAAK,CAAC;QACf,CAAC;QAED,OAAO,MAAM,CAAC,YAAY,KAAK,wCAAmB,CAAC,MAAM,CAAC;IAC5D,CAAC;IAED;;OAEG;IACH,IAAW,YAAY;QACrB,OAAO,IAAI,CAAC,aAAa,CAAC;IAC5B,CAAC;IAED;;OAEG;IACH,IAAW,cAAc;QACvB,OAAO,IAAI,CAAC,eAAe,CAAC;IAC9B,CAAC;CACF;AA7KD,wDA6KC","sourcesContent":["/**\n * ResourceVersionManager - Helper class for managing API version resolution\n *\n * This helper class extracts version management logic from AzapiResource to follow\n * the Single Responsibility Principle. It handles version resolution, validation,\n * and configuration retrieval.\n *\n * @internal\n * @packageDocumentation\n */\n\nimport { ApiVersionManager } from \"../version-manager/api-version-manager\";\nimport {\n  ApiSchema,\n  VersionConfig,\n  VersionSupportLevel,\n} from \"../version-manager/interfaces/version-interfaces\";\n\n/**\n * Helper class for managing API version resolution and configuration\n *\n * This class encapsulates all version-related operations including:\n * - API version resolution (explicit or automatic)\n * - Version validation against registered versions\n * - Schema and configuration retrieval\n * - Latest version resolution\n *\n * @internal\n */\nexport class ResourceVersionManager {\n  private readonly _apiVersionManager: ApiVersionManager;\n  private readonly _resourceType: string;\n  private readonly _defaultVersion: string;\n\n  /**\n   * Creates a new ResourceVersionManager instance\n   *\n   * @param resourceType - The Azure resource type (e.g., \"Microsoft.Resources/resourceGroups\")\n   * @param defaultVersion - The default version to use as fallback\n   */\n  constructor(resourceType: string, defaultVersion: string) {\n    if (!resourceType || resourceType.trim().length === 0) {\n      throw new Error(\"Resource type cannot be empty\");\n    }\n\n    if (!defaultVersion || defaultVersion.trim().length === 0) {\n      throw new Error(\"Default version cannot be empty\");\n    }\n\n    this._resourceType = resourceType;\n    this._defaultVersion = defaultVersion;\n    this._apiVersionManager = ApiVersionManager.instance();\n  }\n\n  /**\n   * Resolves the API version to use for a resource instance\n   *\n   * This method implements the version resolution logic:\n   * 1. If explicitVersion is provided, validate and use it\n   * 2. Otherwise, try to get the latest version from ApiVersionManager\n   * 3. If no versions registered, fall back to defaultVersion\n   *\n   * @param explicitVersion - Optional explicit version specified by user\n   * @returns The resolved API version string\n   * @throws Error if explicit version is provided but not supported\n   */\n  public resolveApiVersion(explicitVersion?: string): string {\n    if (explicitVersion) {\n      // Validate that the explicit version is supported\n      if (!this.validateVersion(explicitVersion)) {\n        const supportedVersions = this.supportedVersions();\n        throw new Error(\n          `Unsupported API version '${explicitVersion}' for resource type '${this._resourceType}'. ` +\n            `Supported versions: ${supportedVersions.join(\", \")}`,\n        );\n      }\n      return explicitVersion;\n    }\n\n    // Try to get the latest version from the manager\n    const latestVersion = this.latestVersion();\n    if (latestVersion) {\n      return latestVersion;\n    }\n\n    // Fall back to the default version\n    console.warn(\n      `No versions registered for ${this._resourceType}. ` +\n        `Using default version: ${this._defaultVersion}. ` +\n        `Consider registering versions with ApiVersionManager for better version management.`,\n    );\n\n    return this._defaultVersion;\n  }\n\n  /**\n   * Retrieves the version configuration for a specific version\n   *\n   * @param version - The version to retrieve configuration for\n   * @returns The version configuration, or undefined if not found\n   */\n  public versionConfig(version: string): VersionConfig | undefined {\n    return this._apiVersionManager.versionConfig(this._resourceType, version);\n  }\n\n  /**\n   * Retrieves the API schema for a specific version\n   *\n   * @param version - The version to retrieve schema for\n   * @returns The API schema for the version\n   * @throws Error if version configuration or schema cannot be found\n   */\n  public schemaForVersion(version: string): ApiSchema {\n    const versionConfig = this.versionConfig(version);\n\n    if (!versionConfig) {\n      throw new Error(\n        `Cannot resolve schema: version configuration not found for ` +\n          `${this._resourceType}@${version}`,\n      );\n    }\n\n    return versionConfig.schema;\n  }\n\n  /**\n   * Validates whether a version is supported for the resource type\n   *\n   * @param version - The version to validate\n   * @returns True if the version is supported, false otherwise\n   */\n  public validateVersion(version: string): boolean {\n    return this._apiVersionManager.validateVersionSupport(\n      this._resourceType,\n      version,\n    );\n  }\n\n  /**\n   * Retrieves the latest available version for the resource type\n   *\n   * @returns The latest version string, or undefined if none found\n   */\n  public latestVersion(): string | undefined {\n    return this._apiVersionManager.latestVersion(this._resourceType);\n  }\n\n  /**\n   * Retrieves all supported versions for the resource type\n   *\n   * @returns Array of supported version strings, sorted by release date (newest first)\n   */\n  public supportedVersions(): string[] {\n    return this._apiVersionManager.supportedVersions(this._resourceType);\n  }\n\n  /**\n   * Checks if the version is deprecated\n   *\n   * @param version - The version to check\n   * @returns True if the version is deprecated or sunset, false otherwise\n   */\n  public isDeprecated(version: string): boolean {\n    const config = this.versionConfig(version);\n    if (!config) {\n      return false;\n    }\n\n    return (\n      config.supportLevel === VersionSupportLevel.DEPRECATED ||\n      config.supportLevel === VersionSupportLevel.SUNSET\n    );\n  }\n\n  /**\n   * Checks if the version has reached sunset\n   *\n   * @param version - The version to check\n   * @returns True if the version has reached sunset, false otherwise\n   */\n  public isSunset(version: string): boolean {\n    const config = this.versionConfig(version);\n    if (!config) {\n      return false;\n    }\n\n    return config.supportLevel === VersionSupportLevel.SUNSET;\n  }\n\n  /**\n   * The resource type this manager is configured for\n   */\n  public get resourceType(): string {\n    return this._resourceType;\n  }\n\n  /**\n   * The default version configured for this manager\n   */\n  public get defaultVersion(): string {\n    return this._defaultVersion;\n  }\n}\n"]}