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

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

@@ -0,0 +1,468 @@
+"use strict";
+var _a, _b, _c;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AzapiDiagnosticSettings = exports.AzapiRoleAssignment = exports.AzapiResource = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/**
+ * AzapiResource - A unified framework for version-aware Azure resource management
+ *
+ * This abstract base class provides a self-contained unified framework approach
+ * for Azure resource management with automatic version management, schema-driven
+ * property transformation, and migration analysis capabilities.
+ *
+ * Key Features:
+ * - Automatic latest version resolution when no version is specified
+ * - Support for explicit version pinning for stability
+ * - Schema-driven property transformation between versions
+ * - Migration analysis and deprecation warnings
+ * - Built-in role assignment and diagnostic settings support
+ * - JSII-compliant design for multi-language support
+ *
+ * This class replaces the previous dual-class approach (AzapiResource + AzapiResource)
+ * with a single, self-contained implementation that handles all resource management needs.
+ *
+ * @packageDocumentation
+ */
+const cdktf = require("cdktf");
+const constructs_1 = require("constructs");
+const data_azapi_client_config_1 = require("./providers-azapi/data-azapi-client-config");
+const resource_1 = require("./providers-azapi/resource");
+const schema_mapper_1 = require("./schema-mapper/schema-mapper");
+const api_version_manager_1 = require("../version-manager/api-version-manager");
+const version_interfaces_1 = require("../version-manager/interfaces/version-interfaces");
+/**
+ * Abstract base class for version-aware Azure resource management
+ *
+ * AzapiResource provides a unified framework for creating Azure resources
+ * with automatic version management, schema validation, property transformation,
+ * and migration analysis. It extends the existing AzapiResource class while
+ * maintaining full backward compatibility.
+ *
+ * This class implements the core framework that enables:
+ * - Automatic resolution of the latest API version when none is specified
+ * - Explicit version pinning for environments requiring stability
+ * - Schema-driven property validation and transformation
+ * - Migration analysis with breaking change detection
+ * - Deprecation warnings and upgrade recommendations
+ *
+ * Subclasses must implement the abstract methods to provide resource-specific
+ * configuration while the framework handles all version management complexity.
+ *
+ * @example Basic usage with automatic version resolution:
+ * class MyResource extends AzapiResource {
+ *   protected getDefaultVersion(): string {
+ *     return "2024-11-01"; // fallback if no versions registered
+ *   }
+ *
+ *   protected getResourceType(): string {
+ *     return "Microsoft.Resources/resourceGroups";
+ *   }
+ *
+ *   protected getApiSchema(): ApiSchema {
+ *     return this.resolveSchema();
+ *   }
+ *
+ *   protected createResourceBody(props: any): any {
+ *     return { location: props.location, tags: props.tags || {} };
+ *   }
+ * }
+ *
+ * @example Usage with explicit version pinning:
+ * new MyResource(this, "resource", {
+ *   name: "my-resource",
+ *   location: "eastus",
+ *   apiVersion: "2024-01-01" // Pin to specific version
+ * });
+ *
+ * @stability stable
+ */
+class AzapiResource extends constructs_1.Construct {
+    /**
+     * Creates a new AzapiResource instance
+     *
+     * The constructor handles all framework initialization including version resolution,
+     * schema loading, property validation, transformation, and migration analysis.
+     * It maintains full backward compatibility with the AzapiResource constructor.
+     *
+     * @param scope - The scope in which to define this construct
+     * @param id - The unique identifier for this instance
+     * @param props - Configuration properties for the resource
+     */
+    constructor(scope, id, props = {}) {
+        // Initialize the base Construct
+        super(scope, id);
+        // Initialize basic properties
+        this.name = props.name || this.node.id;
+        this.location = props.location || "eastus";
+        // Initialize the API version manager
+        this._apiVersionManager = api_version_manager_1.ApiVersionManager.instance();
+        // Step 1: Resolve the API version to use
+        this.resolvedApiVersion = this._resolveApiVersion(props.apiVersion);
+        // Step 2: Set required abstract properties for AzapiResource
+        this._resourceType = this.resourceType();
+        this.apiVersion = this.resolvedApiVersion;
+        // Step 3: Load the schema and version configuration
+        this.schema = this.apiSchema();
+        const versionConfig = this._apiVersionManager.versionConfig(this._resourceType, this.resolvedApiVersion);
+        if (!versionConfig) {
+            throw new Error(`Version configuration not found for ${this.resourceType()}@${this.resolvedApiVersion}. ` +
+                `Please ensure the version is registered with the ApiVersionManager.`);
+        }
+        this.versionConfig = versionConfig;
+        // Step 4: Initialize the schema mapper
+        this._schemaMapper = schema_mapper_1.SchemaMapper.create(this.schema);
+        // Step 5: Process properties through the framework pipeline
+        const processedProps = this._processProperties(props);
+        // Step 6: Perform validation if enabled
+        if (props.enableValidation !== false) {
+            this.validationResult = this._validateProperties(processedProps);
+            if (!this.validationResult.valid) {
+                throw new Error(`Property validation failed for ${this.resourceType}:\n` +
+                    this.validationResult.errors.join("\n"));
+            }
+        }
+        // Step 7: Perform migration analysis if enabled
+        if (props.enableMigrationAnalysis !== false) {
+            this.migrationAnalysis = this._performMigrationAnalysis();
+        }
+        // Step 8: Create the Azure resource
+        this._createAzureResource(processedProps);
+        // Step 9: Log warnings and migration guidance
+        this._logFrameworkMessages();
+    }
+    /**
+     * Helper method for standard schema resolution
+     *
+     * Subclasses can use this method to resolve the schema for the current version
+     * from the ApiVersionManager. This provides a standard implementation that
+     * most resources can use without custom logic.
+     *
+     * @returns The API schema for the resolved version
+     * @throws Error if the schema cannot be resolved
+     */
+    resolveSchema() {
+        const versionConfig = this._apiVersionManager.versionConfig(this.resourceType(), this.resolvedApiVersion);
+        if (!versionConfig) {
+            throw new Error(`Cannot resolve schema: version configuration not found for ` +
+                `${this.resourceType()}@${this.resolvedApiVersion}`);
+        }
+        return versionConfig.schema;
+    }
+    /**
+     * Gets the latest available version for this resource type
+     *
+     * This method provides access to the latest version resolution logic
+     * for use in subclasses or external tooling.
+     *
+     * @returns The latest available version, or undefined if none found
+     */
+    latestVersion() {
+        return this._apiVersionManager.latestVersion(this.resourceType());
+    }
+    /**
+     * Gets all supported versions for this resource type
+     *
+     * This method provides access to the version registry for use in
+     * subclasses or external tooling.
+     *
+     * @returns Array of supported version strings, sorted by release date
+     */
+    supportedVersions() {
+        return this._apiVersionManager.supportedVersions(this.resourceType());
+    }
+    /**
+     * Analyzes migration from current version to a target version
+     *
+     * This method enables external tools to analyze migration requirements
+     * between versions for planning and automation purposes.
+     *
+     * @param targetVersion - The target version to analyze migration to
+     * @returns Detailed migration analysis results
+     */
+    analyzeMigrationTo(targetVersion) {
+        return this._apiVersionManager.analyzeMigration(this.resourceType(), this.resolvedApiVersion, targetVersion);
+    }
+    // =============================================================================
+    // PRIVATE IMPLEMENTATION METHODS
+    // =============================================================================
+    /**
+     * Resolves the API version to use for this resource instance
+     */
+    _resolveApiVersion(explicitVersion) {
+        if (explicitVersion) {
+            // Validate that the explicit version is supported
+            if (!this._apiVersionManager.validateVersionSupport(this.resourceType(), explicitVersion)) {
+                const supportedVersions = this._apiVersionManager.supportedVersions(this.resourceType());
+                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._apiVersionManager.latestVersion(this.resourceType());
+        if (latestVersion) {
+            return latestVersion;
+        }
+        // Fall back to the default version
+        const defaultVersion = this.defaultVersion();
+        // Warn that we're using the default version
+        console.warn(`No versions registered for ${this.resourceType()}. ` +
+            `Using default version: ${defaultVersion}. ` +
+            `Consider registering versions with ApiVersionManager for better version management.`);
+        return defaultVersion;
+    }
+    /**
+     * Processes properties through the framework pipeline
+     */
+    _processProperties(props) {
+        let processedProps = { ...props };
+        // Apply default values from the schema
+        processedProps = this._schemaMapper.applyDefaults(processedProps);
+        // Apply property transformations if enabled
+        if (props.enableTransformation !== false) {
+            // For transformation, we would need a source schema, but since we're not
+            // migrating from a different version in this context, we'll skip transformation
+            // This would be used when upgrading from one version to another
+        }
+        return processedProps;
+    }
+    /**
+     * Validates properties against the schema
+     */
+    _validateProperties(props) {
+        return this._schemaMapper.validateProperties(props);
+    }
+    /**
+     * Performs migration analysis for the current version
+     */
+    _performMigrationAnalysis() {
+        // Check if the current version is deprecated
+        if (this.versionConfig.supportLevel === version_interfaces_1.VersionSupportLevel.DEPRECATED ||
+            this.versionConfig.supportLevel === version_interfaces_1.VersionSupportLevel.SUNSET) {
+            const latestVersion = this.latestVersion();
+            if (latestVersion && latestVersion !== this.resolvedApiVersion) {
+                return this._apiVersionManager.analyzeMigration(this.resourceType(), this.resolvedApiVersion, latestVersion);
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Creates the underlying Azure resource
+     */
+    _createAzureResource(props) {
+        // Create the resource body using the subclass implementation
+        const resourceBody = this.createResourceBody(props);
+        // Determine the parent ID (this would be resource-type specific)
+        const parentId = this._determineParentId(props);
+        // Create the AZAPI resource using the base class method
+        this.terraformResource = this.createAzapiResource(resourceBody, parentId, this.name, this.location);
+    }
+    /**
+     * Determines the parent ID for the resource
+     */
+    _determineParentId(props) {
+        // This is a simplified implementation - real implementation would be
+        // resource-type specific and could be made abstract or configurable
+        // For resource groups, parent is subscription
+        if (this.resourceType() === "Microsoft.Resources/resourceGroups") {
+            // Use AZAPI client config to get subscription ID
+            const clientConfig = new data_azapi_client_config_1.DataAzapiClientConfig(this, "client_config", {});
+            return `/subscriptions/\${${clientConfig.fqn}.subscription_id}`;
+        }
+        // For other resources, parent might be resource group
+        if (props.resourceGroupId) {
+            return props.resourceGroupId;
+        }
+        // Default to subscription
+        const clientConfig = new data_azapi_client_config_1.DataAzapiClientConfig(this, "client_config_default", {});
+        return `/subscriptions/\${${clientConfig.fqn}.subscription_id}`;
+    }
+    /**
+     * Logs framework messages including warnings and migration guidance
+     */
+    _logFrameworkMessages() {
+        // ANSI color codes for terminal output
+        const RED = "\x1b[31m";
+        const YELLOW = "\x1b[33m";
+        const RESET = "\x1b[0m";
+        const BOLD = "\x1b[1m";
+        // Log deprecation warnings
+        if (this.versionConfig.supportLevel === version_interfaces_1.VersionSupportLevel.DEPRECATED) {
+            console.warn(`${YELLOW}⚠️  API version ${this.resolvedApiVersion} for ${this.resourceType()} is deprecated. ` +
+                `Consider upgrading to the latest version: ${this.latestVersion()}${RESET}`);
+        }
+        if (this.versionConfig.supportLevel === version_interfaces_1.VersionSupportLevel.SUNSET) {
+            console.error(`${RED}${BOLD}🚨 API version ${this.resolvedApiVersion} for ${this.resourceType()} has reached sunset. ` +
+                `Immediate migration to ${this.latestVersion()} is required.${RESET}`);
+        }
+        // Log migration analysis results
+        if (this.migrationAnalysis && !this.migrationAnalysis.compatible) {
+            console.warn(`${YELLOW}Migration from ${this.migrationAnalysis.fromVersion} to ${this.migrationAnalysis.toVersion} ` +
+                `has ${this.migrationAnalysis.breakingChanges.length} breaking changes. ` +
+                `Estimated effort: ${this.migrationAnalysis.estimatedEffort}${RESET}`);
+        }
+        // Log validation warnings
+        if (this.validationResult?.warnings.length) {
+            this.validationResult.warnings.forEach((warning) => {
+                console.warn(`${YELLOW}Property validation warning: ${warning}${RESET}`);
+            });
+        }
+    }
+    // =============================================================================
+    // RESOURCE MANAGEMENT METHODS (from AzapiResource)
+    // =============================================================================
+    /**
+     * Creates the underlying AZAPI Terraform resource using the generated provider classes
+     *
+     * @param properties - The properties object to send to the Azure API
+     * @param parentId - The parent resource ID (e.g., subscription or resource group)
+     * @param name - The name of the resource
+     * @param location - The location of the resource (optional, can be in properties)
+     * @returns The created AZAPI resource
+     */
+    createAzapiResource(properties, parentId, name, location) {
+        // Build the configuration object for the generated AZAPI Resource class
+        const config = {
+            type: `${this._resourceType}@${this.apiVersion}`,
+            name: name,
+            parentId: parentId,
+            body: properties,
+            // Add location conditionally if provided and not already in properties
+            ...(location && !properties.location && { location: location }),
+        };
+        // Create and return the AZAPI resource using the generated provider class
+        return new resource_1.Resource(this, "resource", config);
+    }
+    /**
+     * Creates an AZAPI data source for reading existing resources
+     *
+     * @param resourceId - The full resource ID
+     * @returns The created Terraform data source
+     */
+    createAzapiDataSource(resourceId) {
+        const dataSource = new cdktf.TerraformDataSource(this, "data", {
+            terraformResourceType: "azapi_resource",
+            terraformGeneratorMetadata: {
+                providerName: "azapi",
+            },
+        });
+        dataSource.addOverride("type", this._resourceType);
+        dataSource.addOverride("resource_id", resourceId);
+        return dataSource;
+    }
+    /**
+     * Updates the resource with new properties
+     *
+     * @param properties - The new properties to apply
+     */
+    updateAzapiResource(properties) {
+        if (this.terraformResource) {
+            this.terraformResource.addOverride("body", properties);
+        }
+    }
+    /**
+     * Gets the full resource ID
+     */
+    get resourceId() {
+        return this.terraformResource?.fqn || this.id;
+    }
+    /**
+     * Gets the resource as a Terraform output value
+     */
+    get output() {
+        return new cdktf.TerraformOutput(this, "output", {
+            value: this.terraformResource?.fqn,
+        });
+    }
+    /**
+     * Adds an access role assignment for a specified Azure AD object
+     *
+     * Note: This method creates role assignments using AZAPI instead of AzureRM provider.
+     *
+     * @param objectId - The unique identifier of the Azure AD object
+     * @param roleDefinitionName - The name of the Azure RBAC role to be assigned
+     */
+    addAccess(objectId, roleDefinitionName) {
+        new AzapiRoleAssignment(this, `rbac-${objectId}-${roleDefinitionName}`, {
+            objectId: objectId,
+            roleDefinitionName: roleDefinitionName,
+            scope: this.resourceId,
+        });
+    }
+    /**
+     * Adds diagnostic settings to this resource using AZAPI
+     *
+     * @param props - The diagnostic settings configuration
+     */
+    addDiagnosticSettings(props) {
+        return new AzapiDiagnosticSettings(this, "diagnostics", {
+            ...props,
+            targetResourceId: this.resourceId,
+        });
+    }
+}
+exports.AzapiResource = AzapiResource;
+_a = JSII_RTTI_SYMBOL_1;
+AzapiResource[_a] = { fqn: "@microsoft/terraform-cdk-constructs.AzapiResource", version: "1.0.0" };
+/**
+ * AZAPI-based role assignment construct
+ */
+class AzapiRoleAssignment extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        const properties = {
+            principalId: props.objectId,
+            roleDefinitionId: `[subscriptionResourceId('Microsoft.Authorization/roleDefinitions', roleDefinitionId('${props.roleDefinitionName}'))]`,
+            scope: props.scope,
+        };
+        const config = {
+            type: "Microsoft.Authorization/roleAssignments",
+            name: "[guid()]",
+            parentId: props.scope,
+            body: properties,
+        };
+        new resource_1.Resource(this, "role-assignment", config);
+    }
+}
+exports.AzapiRoleAssignment = AzapiRoleAssignment;
+_b = JSII_RTTI_SYMBOL_1;
+AzapiRoleAssignment[_b] = { fqn: "@microsoft/terraform-cdk-constructs.AzapiRoleAssignment", version: "1.0.0" };
+/**
+ * AZAPI-based diagnostic settings construct
+ */
+class AzapiDiagnosticSettings extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        const properties = {};
+        if (props.logAnalyticsWorkspaceId) {
+            properties.workspaceId = props.logAnalyticsWorkspaceId;
+        }
+        if (props.eventhubAuthorizationRuleId) {
+            properties.eventHubAuthorizationRuleId =
+                props.eventhubAuthorizationRuleId;
+        }
+        if (props.eventhubName) {
+            properties.eventHubName = props.eventhubName;
+        }
+        if (props.storageAccountId) {
+            properties.storageAccountId = props.storageAccountId;
+        }
+        if (props.logs) {
+            properties.logs = props.logs;
+        }
+        if (props.metrics) {
+            properties.metrics = props.metrics;
+        }
+        const config = {
+            type: "Microsoft.Insights/diagnosticSettings",
+            name: props.name || "diagnostics",
+            parentId: props.targetResourceId || "",
+            body: properties,
+        };
+        new resource_1.Resource(this, "diagnostic-settings", config);
+    }
+}
+exports.AzapiDiagnosticSettings = AzapiDiagnosticSettings;
+_c = JSII_RTTI_SYMBOL_1;
+AzapiDiagnosticSettings[_c] = { fqn: "@microsoft/terraform-cdk-constructs.AzapiDiagnosticSettings", version: "1.0.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"azapi-resource.js","sourceRoot":"","sources":["../../../../src/core-azure/lib/azapi/azapi-resource.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * AzapiResource - A unified framework for version-aware Azure resource management\n *\n * This abstract base class provides a self-contained unified framework approach\n * for Azure resource management with automatic version management, schema-driven\n * property transformation, and migration analysis capabilities.\n *\n * Key Features:\n * - Automatic latest version resolution when no version is specified\n * - Support for explicit version pinning for stability\n * - Schema-driven property transformation between versions\n * - Migration analysis and deprecation warnings\n * - Built-in role assignment and diagnostic settings support\n * - JSII-compliant design for multi-language support\n *\n * This class replaces the previous dual-class approach (AzapiResource + AzapiResource)\n * with a single, self-contained implementation that handles all resource management needs.\n *\n * @packageDocumentation\n */\n\nimport * as cdktf from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { DataAzapiClientConfig } from \"./providers-azapi/data-azapi-client-config\";\nimport { Resource, ResourceConfig } from \"./providers-azapi/resource\";\nimport { SchemaMapper } from \"./schema-mapper/schema-mapper\";\nimport { ApiVersionManager } from \"../version-manager/api-version-manager\";\nimport {\n  ApiSchema,\n  VersionConfig,\n  ValidationResult,\n  MigrationAnalysis,\n  VersionSupportLevel,\n} from \"../version-manager/interfaces/version-interfaces\";\n\n/**\n * Retention policy configuration\n */\nexport interface RetentionPolicyConfig {\n  readonly enabled: boolean;\n  readonly days: number;\n}\n\n/**\n * Log configuration for diagnostic settings\n */\nexport interface DiagnosticLogConfig {\n  readonly category?: string;\n  readonly categoryGroup?: string;\n  readonly enabled: boolean;\n  readonly retentionPolicy?: RetentionPolicyConfig;\n}\n\n/**\n * Metric configuration for diagnostic settings\n */\nexport interface DiagnosticMetricConfig {\n  readonly category: string;\n  readonly enabled: boolean;\n  readonly retentionPolicy?: RetentionPolicyConfig;\n}\n\n/**\n * Properties for versioned Azure resources\n *\n * Combines base resource properties with version management capabilities\n * and advanced configuration options for the unified framework.\n */\nexport interface AzapiResourceProps {\n  /**\n   * The name of the resource\n   */\n  readonly name?: string;\n\n  /**\n   * The location where the resource should be created\n   */\n  readonly location?: string;\n\n  /**\n   * Tags to apply to the resource\n   */\n  readonly tags?: Record<string, string>;\n  /**\n   * Explicit API version to use for this resource\n   *\n   * If not specified, the latest active version will be automatically resolved.\n   * Use this for version pinning when stability is required over latest features.\n   *\n   * @example \"2024-11-01\"\n   * @defaultValue Latest active version from ApiVersionManager\n   */\n  readonly apiVersion?: string;\n\n  /**\n   * Whether to enable migration analysis warnings\n   *\n   * When true, the framework will analyze the current version for deprecation\n   * status and provide migration recommendations in the deployment output.\n   *\n   * @defaultValue true\n   */\n  readonly enableMigrationAnalysis?: boolean;\n\n  /**\n   * Whether to validate properties against the schema\n   *\n   * When true, all properties will be validated against the API schema before\n   * resource creation. Validation errors will cause deployment failures.\n   *\n   * @defaultValue true\n   */\n  readonly enableValidation?: boolean;\n\n  /**\n   * Whether to apply property transformations automatically\n   *\n   * When true, properties will be automatically transformed according to the\n   * target schema's transformation rules. This enables backward compatibility.\n   *\n   * @defaultValue true\n   */\n  readonly enableTransformation?: boolean;\n}\n\n/**\n * Abstract base class for version-aware Azure resource management\n *\n * AzapiResource provides a unified framework for creating Azure resources\n * with automatic version management, schema validation, property transformation,\n * and migration analysis. It extends the existing AzapiResource class while\n * maintaining full backward compatibility.\n *\n * This class implements the core framework that enables:\n * - Automatic resolution of the latest API version when none is specified\n * - Explicit version pinning for environments requiring stability\n * - Schema-driven property validation and transformation\n * - Migration analysis with breaking change detection\n * - Deprecation warnings and upgrade recommendations\n *\n * Subclasses must implement the abstract methods to provide resource-specific\n * configuration while the framework handles all version management complexity.\n *\n * @example Basic usage with automatic version resolution:\n * class MyResource extends AzapiResource {\n *   protected getDefaultVersion(): string {\n *     return \"2024-11-01\"; // fallback if no versions registered\n *   }\n *\n *   protected getResourceType(): string {\n *     return \"Microsoft.Resources/resourceGroups\";\n *   }\n *\n *   protected getApiSchema(): ApiSchema {\n *     return this.resolveSchema();\n *   }\n *\n *   protected createResourceBody(props: any): any {\n *     return { location: props.location, tags: props.tags || {} };\n *   }\n * }\n *\n * @example Usage with explicit version pinning:\n * new MyResource(this, \"resource\", {\n *   name: \"my-resource\",\n *   location: \"eastus\",\n *   apiVersion: \"2024-01-01\" // Pin to specific version\n * });\n *\n * @stability stable\n */\nexport abstract class AzapiResource extends Construct {\n  /**\n   * The Azure resource type (e.g., \"Microsoft.Resources/resourceGroups\")\n   * @internal\n   */\n  protected readonly _resourceType: string;\n\n  /**\n   * The API version to use for this resource\n   */\n  protected readonly apiVersion: string;\n\n  /**\n   * The underlying AZAPI Terraform resource\n   */\n  protected terraformResource!: cdktf.TerraformResource;\n\n  /**\n   * The name of the resource\n   */\n  public readonly name: string;\n\n  /**\n   * The location of the resource\n   */\n  public readonly location: string;\n\n  /**\n   * The resource ID (abstract - must be implemented by subclasses)\n   */\n  public abstract readonly id: string;\n\n  /**\n   * The resolved API version being used for this resource instance\n   *\n   * This is the actual version that will be used for the Azure API call,\n   * either explicitly specified in props or automatically resolved to\n   * the latest active version.\n   */\n  public readonly resolvedApiVersion: string;\n\n  /**\n   * The API schema for the resolved version\n   *\n   * Contains the complete schema definition including properties, validation\n   * rules, and transformation mappings for the resolved API version.\n   */\n  public readonly schema: ApiSchema;\n\n  /**\n   * The version configuration for the resolved version\n   *\n   * Contains lifecycle information, breaking changes, and migration metadata\n   * for the resolved API version.\n   */\n  public readonly versionConfig: VersionConfig;\n\n  /**\n   * Validation results for the resource properties\n   *\n   * Available after construction if validation is enabled. Contains detailed\n   * information about any validation errors or warnings.\n   */\n  public readonly validationResult?: ValidationResult;\n\n  /**\n   * Migration analysis results\n   *\n   * Available after construction if migration analysis is enabled and a\n   * previous version can be determined for comparison.\n   */\n  public readonly migrationAnalysis?: MigrationAnalysis;\n\n  // Framework components\n  private readonly _apiVersionManager: ApiVersionManager;\n  private readonly _schemaMapper: SchemaMapper;\n\n  /**\n   * Creates a new AzapiResource instance\n   *\n   * The constructor handles all framework initialization including version resolution,\n   * schema loading, property validation, transformation, and migration analysis.\n   * It maintains full backward compatibility with the AzapiResource constructor.\n   *\n   * @param scope - The scope in which to define this construct\n   * @param id - The unique identifier for this instance\n   * @param props - Configuration properties for the resource\n   */\n  constructor(scope: Construct, id: string, props: AzapiResourceProps = {}) {\n    // Initialize the base Construct\n    super(scope, id);\n\n    // Initialize basic properties\n    this.name = props.name || this.node.id;\n    this.location = props.location || \"eastus\";\n\n    // Initialize the API version manager\n    this._apiVersionManager = ApiVersionManager.instance();\n\n    // Step 1: Resolve the API version to use\n    this.resolvedApiVersion = this._resolveApiVersion(props.apiVersion);\n\n    // Step 2: Set required abstract properties for AzapiResource\n    this._resourceType = this.resourceType();\n    this.apiVersion = this.resolvedApiVersion;\n\n    // Step 3: Load the schema and version configuration\n    this.schema = this.apiSchema();\n    const versionConfig = this._apiVersionManager.versionConfig(\n      this._resourceType,\n      this.resolvedApiVersion,\n    );\n\n    if (!versionConfig) {\n      throw new Error(\n        `Version configuration not found for ${this.resourceType()}@${this.resolvedApiVersion}. ` +\n          `Please ensure the version is registered with the ApiVersionManager.`,\n      );\n    }\n    this.versionConfig = versionConfig;\n\n    // Step 4: Initialize the schema mapper\n    this._schemaMapper = SchemaMapper.create(this.schema);\n\n    // Step 5: Process properties through the framework pipeline\n    const processedProps = this._processProperties(props);\n\n    // Step 6: Perform validation if enabled\n    if (props.enableValidation !== false) {\n      this.validationResult = this._validateProperties(processedProps);\n      if (!this.validationResult.valid) {\n        throw new Error(\n          `Property validation failed for ${this.resourceType}:\\n` +\n            this.validationResult.errors.join(\"\\n\"),\n        );\n      }\n    }\n\n    // Step 7: Perform migration analysis if enabled\n    if (props.enableMigrationAnalysis !== false) {\n      this.migrationAnalysis = this._performMigrationAnalysis();\n    }\n\n    // Step 8: Create the Azure resource\n    this._createAzureResource(processedProps);\n\n    // Step 9: Log warnings and migration guidance\n    this._logFrameworkMessages();\n  }\n\n  /**\n   * Gets the default API version to use when no explicit version is specified\n   *\n   * This method should return a sensible default version that can be used\n   * as a fallback if the ApiVersionManager doesn't have any versions registered\n   * for this resource type.\n   *\n   * @returns The default API version string (e.g., \"2024-11-01\")\n   */\n  protected abstract defaultVersion(): string;\n\n  /**\n   * Gets the Azure resource type for this resource\n   *\n   * This method should return the full Azure resource type identifier that\n   * will be used for API calls and version management.\n   *\n   * @returns The Azure resource type (e.g., \"Microsoft.Resources/resourceGroups\")\n   */\n  protected abstract resourceType(): string;\n\n  /**\n   * Gets the API schema for the resolved version\n   *\n   * This method should return the complete API schema for the resolved version,\n   * including all property definitions, validation rules, and transformation\n   * mappings. Use the resolveSchema() helper method for standard schema resolution.\n   *\n   * @returns The API schema for the resolved version\n   */\n  protected abstract apiSchema(): ApiSchema;\n\n  /**\n   * Creates the resource body for the Azure API call\n   *\n   * This method should transform the input properties into the JSON body format\n   * expected by the Azure REST API for the resolved version. The framework will\n   * have already applied any necessary property transformations and validation.\n   *\n   * @param props - The processed and validated properties for the resource\n   * @returns The resource body object to send to Azure API\n   */\n  protected abstract createResourceBody(props: any): any;\n\n  /**\n   * Helper method for standard schema resolution\n   *\n   * Subclasses can use this method to resolve the schema for the current version\n   * from the ApiVersionManager. This provides a standard implementation that\n   * most resources can use without custom logic.\n   *\n   * @returns The API schema for the resolved version\n   * @throws Error if the schema cannot be resolved\n   */\n  protected resolveSchema(): ApiSchema {\n    const versionConfig = this._apiVersionManager.versionConfig(\n      this.resourceType(),\n      this.resolvedApiVersion,\n    );\n\n    if (!versionConfig) {\n      throw new Error(\n        `Cannot resolve schema: version configuration not found for ` +\n          `${this.resourceType()}@${this.resolvedApiVersion}`,\n      );\n    }\n\n    return versionConfig.schema;\n  }\n\n  /**\n   * Gets the latest available version for this resource type\n   *\n   * This method provides access to the latest version resolution logic\n   * for use in subclasses or external tooling.\n   *\n   * @returns The latest available version, or undefined if none found\n   */\n  public latestVersion(): string | undefined {\n    return this._apiVersionManager.latestVersion(this.resourceType());\n  }\n\n  /**\n   * Gets all supported versions for this resource type\n   *\n   * This method provides access to the version registry for use in\n   * subclasses or external tooling.\n   *\n   * @returns Array of supported version strings, sorted by release date\n   */\n  public supportedVersions(): string[] {\n    return this._apiVersionManager.supportedVersions(this.resourceType());\n  }\n\n  /**\n   * Analyzes migration from current version to a target version\n   *\n   * This method enables external tools to analyze migration requirements\n   * between versions for planning and automation purposes.\n   *\n   * @param targetVersion - The target version to analyze migration to\n   * @returns Detailed migration analysis results\n   */\n  public analyzeMigrationTo(targetVersion: string): MigrationAnalysis {\n    return this._apiVersionManager.analyzeMigration(\n      this.resourceType(),\n      this.resolvedApiVersion,\n      targetVersion,\n    );\n  }\n\n  // =============================================================================\n  // PRIVATE IMPLEMENTATION METHODS\n  // =============================================================================\n\n  /**\n   * Resolves the API version to use for this resource instance\n   */\n  private _resolveApiVersion(explicitVersion?: string): string {\n    if (explicitVersion) {\n      // Validate that the explicit version is supported\n      if (\n        !this._apiVersionManager.validateVersionSupport(\n          this.resourceType(),\n          explicitVersion,\n        )\n      ) {\n        const supportedVersions = this._apiVersionManager.supportedVersions(\n          this.resourceType(),\n        );\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._apiVersionManager.latestVersion(\n      this.resourceType(),\n    );\n    if (latestVersion) {\n      return latestVersion;\n    }\n\n    // Fall back to the default version\n    const defaultVersion = this.defaultVersion();\n\n    // Warn that we're using the default version\n    console.warn(\n      `No versions registered for ${this.resourceType()}. ` +\n        `Using default version: ${defaultVersion}. ` +\n        `Consider registering versions with ApiVersionManager for better version management.`,\n    );\n\n    return defaultVersion;\n  }\n\n  /**\n   * Processes properties through the framework pipeline\n   */\n  private _processProperties(props: AzapiResourceProps): any {\n    let processedProps = { ...props };\n\n    // Apply default values from the schema\n    processedProps = this._schemaMapper.applyDefaults(processedProps);\n\n    // Apply property transformations if enabled\n    if (props.enableTransformation !== false) {\n      // For transformation, we would need a source schema, but since we're not\n      // migrating from a different version in this context, we'll skip transformation\n      // This would be used when upgrading from one version to another\n    }\n\n    return processedProps;\n  }\n\n  /**\n   * Validates properties against the schema\n   */\n  private _validateProperties(props: any): ValidationResult {\n    return this._schemaMapper.validateProperties(props);\n  }\n\n  /**\n   * Performs migration analysis for the current version\n   */\n  private _performMigrationAnalysis(): MigrationAnalysis | undefined {\n    // Check if the current version is deprecated\n    if (\n      this.versionConfig.supportLevel === VersionSupportLevel.DEPRECATED ||\n      this.versionConfig.supportLevel === VersionSupportLevel.SUNSET\n    ) {\n      const latestVersion = this.latestVersion();\n      if (latestVersion && latestVersion !== this.resolvedApiVersion) {\n        return this._apiVersionManager.analyzeMigration(\n          this.resourceType(),\n          this.resolvedApiVersion,\n          latestVersion,\n        );\n      }\n    }\n\n    return undefined;\n  }\n\n  /**\n   * Creates the underlying Azure resource\n   */\n  private _createAzureResource(props: any): void {\n    // Create the resource body using the subclass implementation\n    const resourceBody = this.createResourceBody(props);\n\n    // Determine the parent ID (this would be resource-type specific)\n    const parentId = this._determineParentId(props);\n\n    // Create the AZAPI resource using the base class method\n    this.terraformResource = this.createAzapiResource(\n      resourceBody,\n      parentId,\n      this.name,\n      this.location,\n    );\n  }\n\n  /**\n   * Determines the parent ID for the resource\n   */\n  private _determineParentId(props: any): string {\n    // This is a simplified implementation - real implementation would be\n    // resource-type specific and could be made abstract or configurable\n\n    // For resource groups, parent is subscription\n    if (this.resourceType() === \"Microsoft.Resources/resourceGroups\") {\n      // Use AZAPI client config to get subscription ID\n      const clientConfig = new DataAzapiClientConfig(this, \"client_config\", {});\n      return `/subscriptions/\\${${clientConfig.fqn}.subscription_id}`;\n    }\n\n    // For other resources, parent might be resource group\n    if (props.resourceGroupId) {\n      return props.resourceGroupId;\n    }\n\n    // Default to subscription\n    const clientConfig = new DataAzapiClientConfig(\n      this,\n      \"client_config_default\",\n      {},\n    );\n    return `/subscriptions/\\${${clientConfig.fqn}.subscription_id}`;\n  }\n\n  /**\n   * Logs framework messages including warnings and migration guidance\n   */\n  private _logFrameworkMessages(): void {\n    // ANSI color codes for terminal output\n    const RED = \"\\x1b[31m\";\n    const YELLOW = \"\\x1b[33m\";\n    const RESET = \"\\x1b[0m\";\n    const BOLD = \"\\x1b[1m\";\n\n    // Log deprecation warnings\n    if (this.versionConfig.supportLevel === VersionSupportLevel.DEPRECATED) {\n      console.warn(\n        `${YELLOW}⚠️  API version ${this.resolvedApiVersion} for ${this.resourceType()} is deprecated. ` +\n          `Consider upgrading to the latest version: ${this.latestVersion()}${RESET}`,\n      );\n    }\n\n    if (this.versionConfig.supportLevel === VersionSupportLevel.SUNSET) {\n      console.error(\n        `${RED}${BOLD}🚨 API version ${this.resolvedApiVersion} for ${this.resourceType()} has reached sunset. ` +\n          `Immediate migration to ${this.latestVersion()} is required.${RESET}`,\n      );\n    }\n\n    // Log migration analysis results\n    if (this.migrationAnalysis && !this.migrationAnalysis.compatible) {\n      console.warn(\n        `${YELLOW}Migration from ${this.migrationAnalysis.fromVersion} to ${this.migrationAnalysis.toVersion} ` +\n          `has ${this.migrationAnalysis.breakingChanges.length} breaking changes. ` +\n          `Estimated effort: ${this.migrationAnalysis.estimatedEffort}${RESET}`,\n      );\n    }\n\n    // Log validation warnings\n    if (this.validationResult?.warnings.length) {\n      this.validationResult.warnings.forEach((warning) => {\n        console.warn(\n          `${YELLOW}Property validation warning: ${warning}${RESET}`,\n        );\n      });\n    }\n  }\n\n  // =============================================================================\n  // RESOURCE MANAGEMENT METHODS (from AzapiResource)\n  // =============================================================================\n\n  /**\n   * Creates the underlying AZAPI Terraform resource using the generated provider classes\n   *\n   * @param properties - The properties object to send to the Azure API\n   * @param parentId - The parent resource ID (e.g., subscription or resource group)\n   * @param name - The name of the resource\n   * @param location - The location of the resource (optional, can be in properties)\n   * @returns The created AZAPI resource\n   */\n  protected createAzapiResource(\n    properties: Record<string, any>,\n    parentId: string,\n    name: string,\n    location?: string,\n  ): cdktf.TerraformResource {\n    // Build the configuration object for the generated AZAPI Resource class\n    const config: ResourceConfig = {\n      type: `${this._resourceType}@${this.apiVersion}`,\n      name: name,\n      parentId: parentId,\n      body: properties,\n      // Add location conditionally if provided and not already in properties\n      ...(location && !properties.location && { location: location }),\n    };\n\n    // Create and return the AZAPI resource using the generated provider class\n    return new Resource(this, \"resource\", config);\n  }\n\n  /**\n   * Creates an AZAPI data source for reading existing resources\n   *\n   * @param resourceId - The full resource ID\n   * @returns The created Terraform data source\n   */\n  protected createAzapiDataSource(\n    resourceId: string,\n  ): cdktf.TerraformDataSource {\n    const dataSource = new cdktf.TerraformDataSource(this, \"data\", {\n      terraformResourceType: \"azapi_resource\",\n      terraformGeneratorMetadata: {\n        providerName: \"azapi\",\n      },\n    });\n\n    dataSource.addOverride(\"type\", this._resourceType);\n    dataSource.addOverride(\"resource_id\", resourceId);\n\n    return dataSource;\n  }\n\n  /**\n   * Updates the resource with new properties\n   *\n   * @param properties - The new properties to apply\n   */\n  protected updateAzapiResource(properties: Record<string, any>): void {\n    if (this.terraformResource) {\n      this.terraformResource.addOverride(\"body\", properties);\n    }\n  }\n\n  /**\n   * Gets the full resource ID\n   */\n  public get resourceId(): string {\n    return this.terraformResource?.fqn || this.id;\n  }\n\n  /**\n   * Gets the resource as a Terraform output value\n   */\n  public get output(): cdktf.TerraformOutput {\n    return new cdktf.TerraformOutput(this, \"output\", {\n      value: this.terraformResource?.fqn,\n    });\n  }\n\n  /**\n   * Adds an access role assignment for a specified Azure AD object\n   *\n   * Note: This method creates role assignments using AZAPI instead of AzureRM provider.\n   *\n   * @param objectId - The unique identifier of the Azure AD object\n   * @param roleDefinitionName - The name of the Azure RBAC role to be assigned\n   */\n  public addAccess(objectId: string, roleDefinitionName: string): void {\n    new AzapiRoleAssignment(this, `rbac-${objectId}-${roleDefinitionName}`, {\n      objectId: objectId,\n      roleDefinitionName: roleDefinitionName,\n      scope: this.resourceId,\n    });\n  }\n\n  /**\n   * Adds diagnostic settings to this resource using AZAPI\n   *\n   * @param props - The diagnostic settings configuration\n   */\n  public addDiagnosticSettings(\n    props: AzapiDiagnosticSettingsProps,\n  ): AzapiDiagnosticSettings {\n    return new AzapiDiagnosticSettings(this, \"diagnostics\", {\n      ...props,\n      targetResourceId: this.resourceId,\n    });\n  }\n}\n\n// =============================================================================\n// HELPER CLASSES AND INTERFACES\n// =============================================================================\n\n/**\n * Properties for AZAPI role assignment\n */\nexport interface AzapiRoleAssignmentProps {\n  readonly objectId: string;\n  readonly roleDefinitionName: string;\n  readonly scope: string;\n}\n\n/**\n * AZAPI-based role assignment construct\n */\nexport class AzapiRoleAssignment extends Construct {\n  constructor(scope: Construct, id: string, props: AzapiRoleAssignmentProps) {\n    super(scope, id);\n\n    const properties = {\n      principalId: props.objectId,\n      roleDefinitionId: `[subscriptionResourceId('Microsoft.Authorization/roleDefinitions', roleDefinitionId('${props.roleDefinitionName}'))]`,\n      scope: props.scope,\n    };\n\n    const config: ResourceConfig = {\n      type: \"Microsoft.Authorization/roleAssignments\",\n      name: \"[guid()]\",\n      parentId: props.scope,\n      body: properties,\n    };\n\n    new Resource(this, \"role-assignment\", config);\n  }\n}\n\n/**\n * Properties for AZAPI diagnostic settings\n */\nexport interface AzapiDiagnosticSettingsProps {\n  readonly name?: string;\n  readonly logAnalyticsWorkspaceId?: string;\n  readonly eventhubAuthorizationRuleId?: string;\n  readonly eventhubName?: string;\n  readonly storageAccountId?: string;\n  readonly targetResourceId?: string;\n  readonly logs?: DiagnosticLogConfig[];\n  readonly metrics?: DiagnosticMetricConfig[];\n}\n\n/**\n * AZAPI-based diagnostic settings construct\n */\nexport class AzapiDiagnosticSettings extends Construct {\n  constructor(\n    scope: Construct,\n    id: string,\n    props: AzapiDiagnosticSettingsProps,\n  ) {\n    super(scope, id);\n\n    const properties: Record<string, any> = {};\n\n    if (props.logAnalyticsWorkspaceId) {\n      properties.workspaceId = props.logAnalyticsWorkspaceId;\n    }\n\n    if (props.eventhubAuthorizationRuleId) {\n      properties.eventHubAuthorizationRuleId =\n        props.eventhubAuthorizationRuleId;\n    }\n\n    if (props.eventhubName) {\n      properties.eventHubName = props.eventhubName;\n    }\n\n    if (props.storageAccountId) {\n      properties.storageAccountId = props.storageAccountId;\n    }\n\n    if (props.logs) {\n      properties.logs = props.logs;\n    }\n\n    if (props.metrics) {\n      properties.metrics = props.metrics;\n    }\n\n    const config: ResourceConfig = {\n      type: \"Microsoft.Insights/diagnosticSettings\",\n      name: props.name || \"diagnostics\",\n      parentId: props.targetResourceId || \"\",\n      body: properties,\n    };\n\n    new Resource(this, \"diagnostic-settings\", config);\n  }\n}\n"]}

package/lib/core-azure/lib/azapi/azapi-resource.spec.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Comprehensive tests for AzapiResource - Base class for version-aware Azure resources
+ *
+ * This test suite validates the core functionality of the AzapiResource framework,
+ * including version resolution, schema validation, property transformation, and resource creation.
+ */
+export {};