@microsoft/terraform-cdk-constructs 0.0.3-pre.7 → 1.2.0

package/lib/core-azure/lib/azapi/schema-mapper/schema-mapper.js

@@ -0,0 +1,567 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaMapper = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/**
+ * SchemaMapper - A JSII-compliant property transformation engine for Azure API schemas
+ *
+ * This class provides comprehensive property transformation and validation capabilities
+ * for mapping between different API schema versions. It handles property renaming,
+ * restructuring, type conversion, and validation with detailed error reporting.
+ *
+ * Key Features:
+ * - JSII-compliant singleton implementation for multi-language support
+ * - Property transformation with nested object and array support
+ * - Comprehensive validation engine with detailed error reporting
+ * - Default value injection for new properties
+ * - Property path tracking for nested validation errors
+ * - Graceful error handling with contextual information
+ *
+ * @packageDocumentation
+ */
+const version_interfaces_1 = require("../../version-manager/interfaces/version-interfaces");
+/**
+ * SchemaMapper class for property transformation and validation
+ *
+ * This class provides a comprehensive property transformation engine that enables
+ * mapping between different API schema versions with full validation support.
+ * It implements JSII-compliant patterns for multi-language code generation.
+ *
+ * The SchemaMapper handles:
+ * - Property transformation between schema versions
+ * - Validation against API schema definitions
+ * - Default value injection for new properties
+ * - Nested object and array processing
+ * - Detailed error reporting with property paths
+ *
+ * @example
+ * const schema: ApiSchema = {
+ *   resourceType: 'Microsoft.Resources/resourceGroups',
+ *   version: '2024-11-01',
+ *   properties: {
+ *     name: { dataType: PropertyType.STRING, required: true },
+ *     location: { dataType: PropertyType.STRING, required: true }
+ *   },
+ *   required: ['name', 'location']
+ * };
+ *
+ * const mapper = SchemaMapper.create(schema);
+ * const result = mapper.validateProperties({ name: 'myRG', location: 'eastus' });
+ *
+ * @stability stable
+ */
+class SchemaMapper {
+    /**
+     * Creates a new SchemaMapper instance for the specified schema
+     *
+     * This factory method creates a SchemaMapper configured for a specific API schema.
+     * The schema defines the structure, validation rules, and transformation mappings
+     * that will be used for property operations.
+     *
+     * @param schema - The API schema to use for transformations and validation
+     * @returns A new SchemaMapper instance configured with the provided schema
+     *
+     * @throws Error if the schema is invalid or missing required properties
+     *
+     * @example
+     * const schema: ApiSchema = {
+     *   resourceType: 'Microsoft.Resources/resourceGroups',
+     *   version: '2024-11-01',
+     *   properties: { name: { dataType: PropertyType.STRING, required: true } },
+     *   required: ['name']
+     * };
+     * const mapper = SchemaMapper.create(schema);
+     */
+    static create(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");
+        }
+        if (!schema.properties) {
+            throw new Error("Schema must have a properties definition");
+        }
+        if (!schema.required || !Array.isArray(schema.required)) {
+            throw new Error("Schema must have a required properties array");
+        }
+        return new SchemaMapper(schema);
+    }
+    /**
+     * Private constructor to enforce factory pattern
+     *
+     * @param schema - The API schema to use for this mapper instance
+     */
+    constructor(schema) {
+        this._schema = schema;
+        this._errorContexts = [];
+    }
+    /**
+     * Transforms properties from source format to target schema format
+     *
+     * This method applies transformation rules to convert properties from one schema
+     * format to another. It handles property renaming, restructuring, type conversion,
+     * and nested object/array transformations based on the target schema definition.
+     *
+     * @param sourceProps - The source properties to transform
+     * @param targetSchema - The target schema to transform properties to
+     * @returns The transformed properties matching the target schema format
+     *
+     * @throws Error if transformation fails due to incompatible types or missing mappings
+     *
+     * @example
+     * const sourceProps = { oldName: 'value', location: 'eastus' };
+     * const targetSchema = {
+     *   transformationRules: { oldName: 'newName' },
+     *   properties: { newName: { dataType: PropertyType.STRING } }
+     * };
+     * const transformed = mapper.transformProperties(sourceProps, targetSchema);
+     * // Result: { newName: 'value', location: 'eastus' }
+     */
+    transformProperties(sourceProps, targetSchema) {
+        if (!sourceProps) {
+            return {};
+        }
+        if (!targetSchema) {
+            throw new Error("Target schema cannot be undefined or null");
+        }
+        this._clearErrorContexts();
+        const context = {
+            sourcePath: "",
+            targetPath: "",
+            depth: 0,
+        };
+        try {
+            return this._transformObject(sourceProps, targetSchema, context);
+        }
+        catch (error) {
+            throw new Error(`Property transformation failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    }
+    /**
+     * Validates properties against the schema definition
+     *
+     * This method performs comprehensive validation of properties against the
+     * configured schema. It checks required properties, data types, validation rules,
+     * and provides detailed error reporting with property path information.
+     *
+     * @param properties - The properties to validate
+     * @returns Detailed validation results including errors and warnings
+     *
+     * @example
+     * const properties = { name: 'myRG', location: 'eastus', tags: { env: 'dev' } };
+     * const result = mapper.validateProperties(properties);
+     *
+     * if (!result.valid) {
+     *   console.log('Validation errors:', result.errors);
+     *   console.log('Property errors:', result.propertyErrors);
+     * }
+     */
+    validateProperties(properties) {
+        this._clearErrorContexts();
+        const errors = [];
+        const warnings = [];
+        const propertyErrors = {};
+        if (!properties) {
+            errors.push("Properties cannot be undefined or null");
+            return { valid: false, errors, warnings, propertyErrors };
+        }
+        try {
+            // Validate required properties
+            this._validateRequiredProperties(properties, "", errors, propertyErrors);
+            // Validate individual properties
+            this._validateIndividualProperties(properties, "", errors, warnings, propertyErrors);
+            // Apply schema-level validation rules
+            this._applySchemaValidationRules(properties, errors, warnings, propertyErrors);
+        }
+        catch (error) {
+            errors.push(`Validation failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+            warnings,
+            propertyErrors: Object.keys(propertyErrors).length > 0 ? propertyErrors : undefined,
+        };
+    }
+    /**
+     * Applies default values to properties based on schema definitions
+     *
+     * This method injects default values for properties that are not provided
+     * but have default values defined in the schema. It preserves existing
+     * property values and only adds defaults for missing properties.
+     *
+     * @param properties - The properties to apply defaults to
+     * @returns New properties object with default values applied
+     *
+     * @example
+     * const props = { name: 'myRG' };
+     * const withDefaults = mapper.applyDefaults(props);
+     * // If schema defines location default as 'eastus':
+     * // Result: { name: 'myRG', location: 'eastus' }
+     */
+    applyDefaults(properties) {
+        if (!properties) {
+            properties = {};
+        }
+        const result = { ...properties };
+        try {
+            this._applyDefaultsToObject(result, "");
+        }
+        catch (error) {
+            throw new Error(`Default value application failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+        return result;
+    }
+    /**
+     * Maps a single property value using transformation rules
+     *
+     * This method applies transformation logic to a single property value based on
+     * the target property definition. It handles type conversion, value mapping,
+     * and custom transformations.
+     *
+     * @param propertyName - The name of the property being mapped
+     * @param value - The source value to transform
+     * @param targetProperty - The target property definition from the schema
+     * @returns The transformed property value
+     *
+     * @throws Error if the transformation fails or types are incompatible
+     *
+     * @example
+     * const targetProp = { dataType: PropertyType.STRING, required: true };
+     * const mapped = mapper.mapProperty('name', 'myResourceGroup', targetProp);
+     */
+    mapProperty(propertyName, value, targetProperty) {
+        if (!propertyName || propertyName.trim().length === 0) {
+            throw new Error("Property name cannot be empty");
+        }
+        if (!targetProperty) {
+            throw new Error("Target property definition cannot be undefined");
+        }
+        try {
+            return this._transformValue(value, targetProperty, propertyName);
+        }
+        catch (error) {
+            throw new Error(`Property mapping failed for '${propertyName}': ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    }
+    // =============================================================================
+    // PRIVATE HELPER METHODS
+    // =============================================================================
+    /**
+     * Clears the error context array for a new operation
+     */
+    _clearErrorContexts() {
+        this._errorContexts.length = 0;
+    }
+    /**
+     * Transforms an object using the target schema
+     */
+    _transformObject(sourceObj, targetSchema, _context) {
+        if (!sourceObj || typeof sourceObj !== "object") {
+            return sourceObj;
+        }
+        const result = {};
+        const transformationRules = targetSchema.transformationRules || {};
+        // Apply transformation rules first
+        for (const [sourceKey, value] of Object.entries(sourceObj)) {
+            const targetKey = transformationRules[sourceKey] || sourceKey;
+            const targetProperty = targetSchema.properties[targetKey];
+            if (targetProperty) {
+                const transformedValue = this._transformValue(value, targetProperty, targetKey);
+                result[targetKey] = transformedValue;
+            }
+            else {
+                // Property not in target schema - copy as-is unless explicitly excluded
+                result[targetKey] = value;
+            }
+        }
+        return result;
+    }
+    /**
+     * Transforms a single value based on target property definition
+     */
+    _transformValue(value, targetProperty, propertyPath) {
+        if (value === undefined || value === null) {
+            if (targetProperty.defaultValue !== undefined) {
+                return targetProperty.defaultValue;
+            }
+            return value;
+        }
+        switch (targetProperty.dataType) {
+            case version_interfaces_1.PropertyType.STRING:
+                return this._transformToString(value, propertyPath);
+            case version_interfaces_1.PropertyType.NUMBER:
+                return this._transformToNumber(value, propertyPath);
+            case version_interfaces_1.PropertyType.BOOLEAN:
+                return this._transformToBoolean(value, propertyPath);
+            case version_interfaces_1.PropertyType.ARRAY:
+                return this._transformToArray(value, targetProperty, propertyPath);
+            case version_interfaces_1.PropertyType.OBJECT:
+                return this._transformToObject(value, targetProperty, propertyPath);
+            case version_interfaces_1.PropertyType.ANY:
+            default:
+                return value;
+        }
+    }
+    /**
+     * Transforms value to string type
+     */
+    _transformToString(value, propertyPath) {
+        if (typeof value === "string") {
+            return value;
+        }
+        if (typeof value === "number" || typeof value === "boolean") {
+            return String(value);
+        }
+        throw new Error(`Cannot convert value at '${propertyPath}' to string. Got: ${typeof value}`);
+    }
+    /**
+     * Transforms value to number type
+     */
+    _transformToNumber(value, propertyPath) {
+        if (typeof value === "number") {
+            return value;
+        }
+        if (typeof value === "string") {
+            const parsed = Number(value);
+            if (!isNaN(parsed)) {
+                return parsed;
+            }
+        }
+        throw new Error(`Cannot convert value at '${propertyPath}' to number. Got: ${typeof value}`);
+    }
+    /**
+     * Transforms value to boolean type
+     */
+    _transformToBoolean(value, propertyPath) {
+        if (typeof value === "boolean") {
+            return value;
+        }
+        if (typeof value === "string") {
+            const lower = value.toLowerCase();
+            if (lower === "true" || lower === "1")
+                return true;
+            if (lower === "false" || lower === "0")
+                return false;
+        }
+        if (typeof value === "number") {
+            return value !== 0;
+        }
+        throw new Error(`Cannot convert value at '${propertyPath}' to boolean. Got: ${typeof value}`);
+    }
+    /**
+     * Transforms value to array type
+     */
+    _transformToArray(value, _targetProperty, propertyPath) {
+        if (Array.isArray(value)) {
+            return value; // TODO: Transform array elements if needed
+        }
+        throw new Error(`Expected array at '${propertyPath}', got: ${typeof value}`);
+    }
+    /**
+     * Transforms value to object type
+     */
+    _transformToObject(value, _targetProperty, propertyPath) {
+        if (value && typeof value === "object" && !Array.isArray(value)) {
+            return value; // TODO: Apply nested transformation rules if needed
+        }
+        throw new Error(`Expected object at '${propertyPath}', got: ${typeof value}`);
+    }
+    /**
+     * Validates required properties
+     */
+    _validateRequiredProperties(properties, basePath, errors, propertyErrors) {
+        for (const requiredProp of this._schema.required) {
+            const fullPath = basePath ? `${basePath}.${requiredProp}` : requiredProp;
+            if (!(requiredProp in properties) ||
+                properties[requiredProp] === undefined) {
+                const error = `Required property '${requiredProp}' is missing`;
+                errors.push(error);
+                if (!propertyErrors[fullPath]) {
+                    propertyErrors[fullPath] = [];
+                }
+                propertyErrors[fullPath].push(error);
+            }
+        }
+    }
+    /**
+     * Validates individual properties against their definitions
+     */
+    _validateIndividualProperties(properties, basePath, errors, warnings, propertyErrors) {
+        // Framework properties that should not be validated against Azure API schema
+        const frameworkProperties = new Set([
+            "apiVersion",
+            "enableMigrationAnalysis",
+            "enableValidation",
+            "enableTransformation",
+            "ignoreChanges",
+            "resourceGroupId",
+            "monitoring", // Framework-level monitoring configuration
+            "virtualNetworkId", // Framework-level dependency tracking for child resources
+        ]);
+        for (const [propName, propValue] of Object.entries(properties)) {
+            const fullPath = basePath ? `${basePath}.${propName}` : propName;
+            // Skip framework properties
+            if (frameworkProperties.has(propName)) {
+                continue;
+            }
+            const propDef = this._schema.properties[propName];
+            if (!propDef) {
+                warnings.push(`Unknown property '${propName}' not defined in schema`);
+                continue;
+            }
+            // Check if property is deprecated
+            if (propDef.deprecated) {
+                warnings.push(`Property '${propName}' is deprecated`);
+            }
+            // Validate property type
+            const typeErrors = this._validatePropertyType(propValue, propDef, fullPath);
+            if (typeErrors.length > 0) {
+                errors.push(...typeErrors);
+                if (!propertyErrors[fullPath]) {
+                    propertyErrors[fullPath] = [];
+                }
+                propertyErrors[fullPath].push(...typeErrors);
+            }
+            // Apply validation rules
+            if (propDef.validation) {
+                const ruleErrors = this._applyValidationRules(propValue, propDef.validation, fullPath);
+                if (ruleErrors.length > 0) {
+                    errors.push(...ruleErrors);
+                    if (!propertyErrors[fullPath]) {
+                        propertyErrors[fullPath] = [];
+                    }
+                    propertyErrors[fullPath].push(...ruleErrors);
+                }
+            }
+        }
+    }
+    /**
+     * Validates property type against definition
+     */
+    _validatePropertyType(value, propDef, propertyPath) {
+        const errors = [];
+        if (value === undefined || value === null) {
+            if (propDef.required) {
+                errors.push(`Property '${propertyPath}' is required but is ${value === null ? "null" : "undefined"}`);
+            }
+            return errors;
+        }
+        switch (propDef.dataType) {
+            case version_interfaces_1.PropertyType.STRING:
+                if (typeof value !== "string") {
+                    errors.push(`Property '${propertyPath}' must be a string, got: ${typeof value}`);
+                }
+                break;
+            case version_interfaces_1.PropertyType.NUMBER:
+                if (typeof value !== "number") {
+                    errors.push(`Property '${propertyPath}' must be a number, got: ${typeof value}`);
+                }
+                break;
+            case version_interfaces_1.PropertyType.BOOLEAN:
+                if (typeof value !== "boolean") {
+                    errors.push(`Property '${propertyPath}' must be a boolean, got: ${typeof value}`);
+                }
+                break;
+            case version_interfaces_1.PropertyType.ARRAY:
+                if (!Array.isArray(value)) {
+                    errors.push(`Property '${propertyPath}' must be an array, got: ${typeof value}`);
+                }
+                break;
+            case version_interfaces_1.PropertyType.OBJECT:
+                if (typeof value !== "object" || Array.isArray(value)) {
+                    errors.push(`Property '${propertyPath}' must be an object, got: ${typeof value}`);
+                }
+                break;
+            case version_interfaces_1.PropertyType.ANY:
+                // Any type is always valid
+                break;
+            default:
+                errors.push(`Unknown data type '${propDef.dataType}' for property '${propertyPath}'`);
+        }
+        return errors;
+    }
+    /**
+     * Applies validation rules to a property value
+     */
+    _applyValidationRules(value, rules, propertyPath) {
+        const errors = [];
+        for (const rule of rules) {
+            switch (rule.ruleType) {
+                case version_interfaces_1.ValidationRuleType.REQUIRED:
+                    if (value === undefined || value === null || value === "") {
+                        errors.push(rule.message || `Property '${propertyPath}' is required`);
+                    }
+                    break;
+                case version_interfaces_1.ValidationRuleType.PATTERN_MATCH:
+                    if (typeof value === "string" && rule.value) {
+                        const pattern = new RegExp(rule.value);
+                        if (!pattern.test(value)) {
+                            errors.push(rule.message ||
+                                `Property '${propertyPath}' does not match required pattern`);
+                        }
+                    }
+                    break;
+                case version_interfaces_1.ValidationRuleType.VALUE_RANGE:
+                    if (typeof value === "number" && rule.value) {
+                        const range = rule.value;
+                        if (range.min !== undefined && value < range.min) {
+                            errors.push(rule.message ||
+                                `Property '${propertyPath}' must be at least ${range.min}`);
+                        }
+                        if (range.max !== undefined && value > range.max) {
+                            errors.push(rule.message ||
+                                `Property '${propertyPath}' must be at most ${range.max}`);
+                        }
+                    }
+                    break;
+                case version_interfaces_1.ValidationRuleType.TYPE_CHECK:
+                    // Type checking is handled in _validatePropertyType
+                    break;
+                case version_interfaces_1.ValidationRuleType.CUSTOM_VALIDATION:
+                    // Custom validation would require function support, which is complex in JSII
+                    // For now, we'll just log a warning
+                    break;
+            }
+        }
+        return errors;
+    }
+    /**
+     * Applies schema-level validation rules
+     */
+    _applySchemaValidationRules(properties, errors, _warnings, propertyErrors) {
+        if (!this._schema.validationRules) {
+            return;
+        }
+        for (const validation of this._schema.validationRules) {
+            const propValue = properties[validation.property];
+            const ruleErrors = this._applyValidationRules(propValue, validation.rules, validation.property);
+            if (ruleErrors.length > 0) {
+                errors.push(...ruleErrors);
+                if (!propertyErrors[validation.property]) {
+                    propertyErrors[validation.property] = [];
+                }
+                propertyErrors[validation.property].push(...ruleErrors);
+            }
+        }
+    }
+    /**
+     * Applies default values to an object
+     */
+    _applyDefaultsToObject(obj, _basePath) {
+        for (const [propName, propDef] of Object.entries(this._schema.properties)) {
+            if (!(propName in obj) && propDef.defaultValue !== undefined) {
+                obj[propName] = propDef.defaultValue;
+            }
+        }
+    }
+}
+exports.SchemaMapper = SchemaMapper;
+_a = JSII_RTTI_SYMBOL_1;
+SchemaMapper[_a] = { fqn: "@microsoft/terraform-cdk-constructs.SchemaMapper", version: "1.2.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"schema-mapper.js","sourceRoot":"","sources":["../../../../../src/core-azure/lib/azapi/schema-mapper/schema-mapper.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * SchemaMapper - A JSII-compliant property transformation engine for Azure API schemas\n *\n * This class provides comprehensive property transformation and validation capabilities\n * for mapping between different API schema versions. It handles property renaming,\n * restructuring, type conversion, and validation with detailed error reporting.\n *\n * Key Features:\n * - JSII-compliant singleton implementation for multi-language support\n * - Property transformation with nested object and array support\n * - Comprehensive validation engine with detailed error reporting\n * - Default value injection for new properties\n * - Property path tracking for nested validation errors\n * - Graceful error handling with contextual information\n *\n * @packageDocumentation\n */\n\nimport {\n  ApiSchema,\n  PropertyDefinition,\n  ValidationResult,\n  ValidationRule,\n  PropertyType,\n  ValidationRuleType,\n} from \"../../version-manager/interfaces/version-interfaces\";\n\n/**\n * Error context for property transformation and validation\n */\ninterface ErrorContext {\n  readonly propertyPath: string;\n  readonly message: string;\n  readonly sourceValue?: any;\n  readonly expectedType?: string;\n}\n\n/**\n * Transformation context for tracking nested transformations\n */\ninterface TransformationContext {\n  readonly sourcePath: string;\n  readonly targetPath: string;\n  readonly depth: number;\n}\n\n/**\n * SchemaMapper class for property transformation and validation\n *\n * This class provides a comprehensive property transformation engine that enables\n * mapping between different API schema versions with full validation support.\n * It implements JSII-compliant patterns for multi-language code generation.\n *\n * The SchemaMapper handles:\n * - Property transformation between schema versions\n * - Validation against API schema definitions\n * - Default value injection for new properties\n * - Nested object and array processing\n * - Detailed error reporting with property paths\n *\n * @example\n * const schema: ApiSchema = {\n *   resourceType: 'Microsoft.Resources/resourceGroups',\n *   version: '2024-11-01',\n *   properties: {\n *     name: { dataType: PropertyType.STRING, required: true },\n *     location: { dataType: PropertyType.STRING, required: true }\n *   },\n *   required: ['name', 'location']\n * };\n *\n * const mapper = SchemaMapper.create(schema);\n * const result = mapper.validateProperties({ name: 'myRG', location: 'eastus' });\n *\n * @stability stable\n */\nexport class SchemaMapper {\n  /**\n   * Creates a new SchemaMapper instance for the specified schema\n   *\n   * This factory method creates a SchemaMapper configured for a specific API schema.\n   * The schema defines the structure, validation rules, and transformation mappings\n   * that will be used for property operations.\n   *\n   * @param schema - The API schema to use for transformations and validation\n   * @returns A new SchemaMapper instance configured with the provided schema\n   *\n   * @throws Error if the schema is invalid or missing required properties\n   *\n   * @example\n   * const schema: ApiSchema = {\n   *   resourceType: 'Microsoft.Resources/resourceGroups',\n   *   version: '2024-11-01',\n   *   properties: { name: { dataType: PropertyType.STRING, required: true } },\n   *   required: ['name']\n   * };\n   * const mapper = SchemaMapper.create(schema);\n   */\n  public static create(schema: ApiSchema): SchemaMapper {\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    if (!schema.properties) {\n      throw new Error(\"Schema must have a properties definition\");\n    }\n\n    if (!schema.required || !Array.isArray(schema.required)) {\n      throw new Error(\"Schema must have a required properties array\");\n    }\n\n    return new SchemaMapper(schema);\n  }\n\n  private readonly _schema: ApiSchema;\n  private readonly _errorContexts: ErrorContext[];\n\n  /**\n   * Private constructor to enforce factory pattern\n   *\n   * @param schema - The API schema to use for this mapper instance\n   */\n  private constructor(schema: ApiSchema) {\n    this._schema = schema;\n    this._errorContexts = [];\n  }\n\n  /**\n   * Transforms properties from source format to target schema format\n   *\n   * This method applies transformation rules to convert properties from one schema\n   * format to another. It handles property renaming, restructuring, type conversion,\n   * and nested object/array transformations based on the target schema definition.\n   *\n   * @param sourceProps - The source properties to transform\n   * @param targetSchema - The target schema to transform properties to\n   * @returns The transformed properties matching the target schema format\n   *\n   * @throws Error if transformation fails due to incompatible types or missing mappings\n   *\n   * @example\n   * const sourceProps = { oldName: 'value', location: 'eastus' };\n   * const targetSchema = {\n   *   transformationRules: { oldName: 'newName' },\n   *   properties: { newName: { dataType: PropertyType.STRING } }\n   * };\n   * const transformed = mapper.transformProperties(sourceProps, targetSchema);\n   * // Result: { newName: 'value', location: 'eastus' }\n   */\n  public transformProperties(sourceProps: any, targetSchema: ApiSchema): any {\n    if (!sourceProps) {\n      return {};\n    }\n\n    if (!targetSchema) {\n      throw new Error(\"Target schema cannot be undefined or null\");\n    }\n\n    this._clearErrorContexts();\n    const context: TransformationContext = {\n      sourcePath: \"\",\n      targetPath: \"\",\n      depth: 0,\n    };\n\n    try {\n      return this._transformObject(sourceProps, targetSchema, context);\n    } catch (error) {\n      throw new Error(\n        `Property transformation failed: ${error instanceof Error ? error.message : \"Unknown error\"}`,\n      );\n    }\n  }\n\n  /**\n   * Validates properties against the schema definition\n   *\n   * This method performs comprehensive validation of properties against the\n   * configured schema. It checks required properties, data types, validation rules,\n   * and provides detailed error reporting with property path information.\n   *\n   * @param properties - The properties to validate\n   * @returns Detailed validation results including errors and warnings\n   *\n   * @example\n   * const properties = { name: 'myRG', location: 'eastus', tags: { env: 'dev' } };\n   * const result = mapper.validateProperties(properties);\n   *\n   * if (!result.valid) {\n   *   console.log('Validation errors:', result.errors);\n   *   console.log('Property errors:', result.propertyErrors);\n   * }\n   */\n  public validateProperties(properties: any): ValidationResult {\n    this._clearErrorContexts();\n    const errors: string[] = [];\n    const warnings: string[] = [];\n    const propertyErrors: { [key: string]: string[] } = {};\n\n    if (!properties) {\n      errors.push(\"Properties cannot be undefined or null\");\n      return { valid: false, errors, warnings, propertyErrors };\n    }\n\n    try {\n      // Validate required properties\n      this._validateRequiredProperties(properties, \"\", errors, propertyErrors);\n\n      // Validate individual properties\n      this._validateIndividualProperties(\n        properties,\n        \"\",\n        errors,\n        warnings,\n        propertyErrors,\n      );\n\n      // Apply schema-level validation rules\n      this._applySchemaValidationRules(\n        properties,\n        errors,\n        warnings,\n        propertyErrors,\n      );\n    } catch (error) {\n      errors.push(\n        `Validation failed: ${error instanceof Error ? error.message : \"Unknown error\"}`,\n      );\n    }\n\n    return {\n      valid: errors.length === 0,\n      errors,\n      warnings,\n      propertyErrors:\n        Object.keys(propertyErrors).length > 0 ? propertyErrors : undefined,\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 default values defined in the schema. It preserves existing\n   * property values and only adds defaults for missing properties.\n   *\n   * @param properties - The properties to apply defaults to\n   * @returns New properties object with default values applied\n   *\n   * @example\n   * const props = { name: 'myRG' };\n   * const withDefaults = mapper.applyDefaults(props);\n   * // If schema defines location default as 'eastus':\n   * // Result: { name: 'myRG', location: 'eastus' }\n   */\n  public applyDefaults(properties: any): any {\n    if (!properties) {\n      properties = {};\n    }\n\n    const result = { ...properties };\n\n    try {\n      this._applyDefaultsToObject(result, \"\");\n    } catch (error) {\n      throw new Error(\n        `Default value application failed: ${error instanceof Error ? error.message : \"Unknown error\"}`,\n      );\n    }\n\n    return result;\n  }\n\n  /**\n   * Maps a single property value using transformation rules\n   *\n   * This method applies transformation logic to a single property value based on\n   * the target property definition. It handles type conversion, value mapping,\n   * and custom transformations.\n   *\n   * @param propertyName - The name of the property being mapped\n   * @param value - The source value to transform\n   * @param targetProperty - The target property definition from the schema\n   * @returns The transformed property value\n   *\n   * @throws Error if the transformation fails or types are incompatible\n   *\n   * @example\n   * const targetProp = { dataType: PropertyType.STRING, required: true };\n   * const mapped = mapper.mapProperty('name', 'myResourceGroup', targetProp);\n   */\n  public mapProperty(\n    propertyName: string,\n    value: any,\n    targetProperty: PropertyDefinition,\n  ): any {\n    if (!propertyName || propertyName.trim().length === 0) {\n      throw new Error(\"Property name cannot be empty\");\n    }\n\n    if (!targetProperty) {\n      throw new Error(\"Target property definition cannot be undefined\");\n    }\n\n    try {\n      return this._transformValue(value, targetProperty, propertyName);\n    } catch (error) {\n      throw new Error(\n        `Property mapping failed for '${propertyName}': ${error instanceof Error ? error.message : \"Unknown error\"}`,\n      );\n    }\n  }\n\n  // =============================================================================\n  // PRIVATE HELPER METHODS\n  // =============================================================================\n\n  /**\n   * Clears the error context array for a new operation\n   */\n  private _clearErrorContexts(): void {\n    this._errorContexts.length = 0;\n  }\n\n  /**\n   * Transforms an object using the target schema\n   */\n  private _transformObject(\n    sourceObj: any,\n    targetSchema: ApiSchema,\n    _context: TransformationContext,\n  ): any {\n    if (!sourceObj || typeof sourceObj !== \"object\") {\n      return sourceObj;\n    }\n\n    const result: any = {};\n    const transformationRules = targetSchema.transformationRules || {};\n\n    // Apply transformation rules first\n    for (const [sourceKey, value] of Object.entries(sourceObj)) {\n      const targetKey = transformationRules[sourceKey] || sourceKey;\n      const targetProperty = targetSchema.properties[targetKey];\n\n      if (targetProperty) {\n        const transformedValue = this._transformValue(\n          value,\n          targetProperty,\n          targetKey,\n        );\n        result[targetKey] = transformedValue;\n      } else {\n        // Property not in target schema - copy as-is unless explicitly excluded\n        result[targetKey] = value;\n      }\n    }\n\n    return result;\n  }\n\n  /**\n   * Transforms a single value based on target property definition\n   */\n  private _transformValue(\n    value: any,\n    targetProperty: PropertyDefinition,\n    propertyPath: string,\n  ): any {\n    if (value === undefined || value === null) {\n      if (targetProperty.defaultValue !== undefined) {\n        return targetProperty.defaultValue;\n      }\n      return value;\n    }\n\n    switch (targetProperty.dataType) {\n      case PropertyType.STRING:\n        return this._transformToString(value, propertyPath);\n\n      case PropertyType.NUMBER:\n        return this._transformToNumber(value, propertyPath);\n\n      case PropertyType.BOOLEAN:\n        return this._transformToBoolean(value, propertyPath);\n\n      case PropertyType.ARRAY:\n        return this._transformToArray(value, targetProperty, propertyPath);\n\n      case PropertyType.OBJECT:\n        return this._transformToObject(value, targetProperty, propertyPath);\n\n      case PropertyType.ANY:\n      default:\n        return value;\n    }\n  }\n\n  /**\n   * Transforms value to string type\n   */\n  private _transformToString(value: any, propertyPath: string): string {\n    if (typeof value === \"string\") {\n      return value;\n    }\n\n    if (typeof value === \"number\" || typeof value === \"boolean\") {\n      return String(value);\n    }\n\n    throw new Error(\n      `Cannot convert value at '${propertyPath}' to string. Got: ${typeof value}`,\n    );\n  }\n\n  /**\n   * Transforms value to number type\n   */\n  private _transformToNumber(value: any, propertyPath: string): number {\n    if (typeof value === \"number\") {\n      return value;\n    }\n\n    if (typeof value === \"string\") {\n      const parsed = Number(value);\n      if (!isNaN(parsed)) {\n        return parsed;\n      }\n    }\n\n    throw new Error(\n      `Cannot convert value at '${propertyPath}' to number. Got: ${typeof value}`,\n    );\n  }\n\n  /**\n   * Transforms value to boolean type\n   */\n  private _transformToBoolean(value: any, propertyPath: string): boolean {\n    if (typeof value === \"boolean\") {\n      return value;\n    }\n\n    if (typeof value === \"string\") {\n      const lower = value.toLowerCase();\n      if (lower === \"true\" || lower === \"1\") return true;\n      if (lower === \"false\" || lower === \"0\") return false;\n    }\n\n    if (typeof value === \"number\") {\n      return value !== 0;\n    }\n\n    throw new Error(\n      `Cannot convert value at '${propertyPath}' to boolean. Got: ${typeof value}`,\n    );\n  }\n\n  /**\n   * Transforms value to array type\n   */\n  private _transformToArray(\n    value: any,\n    _targetProperty: PropertyDefinition,\n    propertyPath: string,\n  ): any[] {\n    if (Array.isArray(value)) {\n      return value; // TODO: Transform array elements if needed\n    }\n\n    throw new Error(\n      `Expected array at '${propertyPath}', got: ${typeof value}`,\n    );\n  }\n\n  /**\n   * Transforms value to object type\n   */\n  private _transformToObject(\n    value: any,\n    _targetProperty: PropertyDefinition,\n    propertyPath: string,\n  ): any {\n    if (value && typeof value === \"object\" && !Array.isArray(value)) {\n      return value; // TODO: Apply nested transformation rules if needed\n    }\n\n    throw new Error(\n      `Expected object at '${propertyPath}', got: ${typeof value}`,\n    );\n  }\n\n  /**\n   * Validates required properties\n   */\n  private _validateRequiredProperties(\n    properties: any,\n    basePath: string,\n    errors: string[],\n    propertyErrors: { [key: string]: string[] },\n  ): void {\n    for (const requiredProp of this._schema.required) {\n      const fullPath = basePath ? `${basePath}.${requiredProp}` : requiredProp;\n\n      if (\n        !(requiredProp in properties) ||\n        properties[requiredProp] === undefined\n      ) {\n        const error = `Required property '${requiredProp}' is missing`;\n        errors.push(error);\n\n        if (!propertyErrors[fullPath]) {\n          propertyErrors[fullPath] = [];\n        }\n        propertyErrors[fullPath].push(error);\n      }\n    }\n  }\n\n  /**\n   * Validates individual properties against their definitions\n   */\n  private _validateIndividualProperties(\n    properties: any,\n    basePath: string,\n    errors: string[],\n    warnings: string[],\n    propertyErrors: { [key: string]: string[] },\n  ): void {\n    // Framework properties that should not be validated against Azure API schema\n    const frameworkProperties = new Set([\n      \"apiVersion\",\n      \"enableMigrationAnalysis\",\n      \"enableValidation\",\n      \"enableTransformation\",\n      \"ignoreChanges\",\n      \"resourceGroupId\",\n      \"monitoring\", // Framework-level monitoring configuration\n      \"virtualNetworkId\", // Framework-level dependency tracking for child resources\n    ]);\n\n    for (const [propName, propValue] of Object.entries(properties)) {\n      const fullPath = basePath ? `${basePath}.${propName}` : propName;\n\n      // Skip framework properties\n      if (frameworkProperties.has(propName)) {\n        continue;\n      }\n\n      const propDef = this._schema.properties[propName];\n\n      if (!propDef) {\n        warnings.push(`Unknown property '${propName}' not defined in schema`);\n        continue;\n      }\n\n      // Check if property is deprecated\n      if (propDef.deprecated) {\n        warnings.push(`Property '${propName}' is deprecated`);\n      }\n\n      // Validate property type\n      const typeErrors = this._validatePropertyType(\n        propValue,\n        propDef,\n        fullPath,\n      );\n      if (typeErrors.length > 0) {\n        errors.push(...typeErrors);\n\n        if (!propertyErrors[fullPath]) {\n          propertyErrors[fullPath] = [];\n        }\n        propertyErrors[fullPath].push(...typeErrors);\n      }\n\n      // Apply validation rules\n      if (propDef.validation) {\n        const ruleErrors = this._applyValidationRules(\n          propValue,\n          propDef.validation,\n          fullPath,\n        );\n        if (ruleErrors.length > 0) {\n          errors.push(...ruleErrors);\n\n          if (!propertyErrors[fullPath]) {\n            propertyErrors[fullPath] = [];\n          }\n          propertyErrors[fullPath].push(...ruleErrors);\n        }\n      }\n    }\n  }\n\n  /**\n   * Validates property type against definition\n   */\n  private _validatePropertyType(\n    value: any,\n    propDef: PropertyDefinition,\n    propertyPath: string,\n  ): string[] {\n    const errors: string[] = [];\n\n    if (value === undefined || value === null) {\n      if (propDef.required) {\n        errors.push(\n          `Property '${propertyPath}' is required but is ${value === null ? \"null\" : \"undefined\"}`,\n        );\n      }\n      return errors;\n    }\n\n    switch (propDef.dataType) {\n      case PropertyType.STRING:\n        if (typeof value !== \"string\") {\n          errors.push(\n            `Property '${propertyPath}' must be a string, got: ${typeof value}`,\n          );\n        }\n        break;\n\n      case PropertyType.NUMBER:\n        if (typeof value !== \"number\") {\n          errors.push(\n            `Property '${propertyPath}' must be a number, got: ${typeof value}`,\n          );\n        }\n        break;\n\n      case PropertyType.BOOLEAN:\n        if (typeof value !== \"boolean\") {\n          errors.push(\n            `Property '${propertyPath}' must be a boolean, got: ${typeof value}`,\n          );\n        }\n        break;\n\n      case PropertyType.ARRAY:\n        if (!Array.isArray(value)) {\n          errors.push(\n            `Property '${propertyPath}' must be an array, got: ${typeof value}`,\n          );\n        }\n        break;\n\n      case PropertyType.OBJECT:\n        if (typeof value !== \"object\" || Array.isArray(value)) {\n          errors.push(\n            `Property '${propertyPath}' must be an object, got: ${typeof value}`,\n          );\n        }\n        break;\n\n      case PropertyType.ANY:\n        // Any type is always valid\n        break;\n\n      default:\n        errors.push(\n          `Unknown data type '${propDef.dataType}' for property '${propertyPath}'`,\n        );\n    }\n\n    return errors;\n  }\n\n  /**\n   * Applies validation rules to a property value\n   */\n  private _applyValidationRules(\n    value: any,\n    rules: ValidationRule[],\n    propertyPath: string,\n  ): string[] {\n    const errors: string[] = [];\n\n    for (const rule of rules) {\n      switch (rule.ruleType) {\n        case ValidationRuleType.REQUIRED:\n          if (value === undefined || value === null || value === \"\") {\n            errors.push(\n              rule.message || `Property '${propertyPath}' is required`,\n            );\n          }\n          break;\n\n        case ValidationRuleType.PATTERN_MATCH:\n          if (typeof value === \"string\" && rule.value) {\n            const pattern = new RegExp(rule.value);\n            if (!pattern.test(value)) {\n              errors.push(\n                rule.message ||\n                  `Property '${propertyPath}' does not match required pattern`,\n              );\n            }\n          }\n          break;\n\n        case ValidationRuleType.VALUE_RANGE:\n          if (typeof value === \"number\" && rule.value) {\n            const range = rule.value;\n            if (range.min !== undefined && value < range.min) {\n              errors.push(\n                rule.message ||\n                  `Property '${propertyPath}' must be at least ${range.min}`,\n              );\n            }\n            if (range.max !== undefined && value > range.max) {\n              errors.push(\n                rule.message ||\n                  `Property '${propertyPath}' must be at most ${range.max}`,\n              );\n            }\n          }\n          break;\n\n        case ValidationRuleType.TYPE_CHECK:\n          // Type checking is handled in _validatePropertyType\n          break;\n\n        case ValidationRuleType.CUSTOM_VALIDATION:\n          // Custom validation would require function support, which is complex in JSII\n          // For now, we'll just log a warning\n          break;\n      }\n    }\n\n    return errors;\n  }\n\n  /**\n   * Applies schema-level validation rules\n   */\n  private _applySchemaValidationRules(\n    properties: any,\n    errors: string[],\n    _warnings: string[],\n    propertyErrors: { [key: string]: string[] },\n  ): void {\n    if (!this._schema.validationRules) {\n      return;\n    }\n\n    for (const validation of this._schema.validationRules) {\n      const propValue = properties[validation.property];\n      const ruleErrors = this._applyValidationRules(\n        propValue,\n        validation.rules,\n        validation.property,\n      );\n      if (ruleErrors.length > 0) {\n        errors.push(...ruleErrors);\n\n        if (!propertyErrors[validation.property]) {\n          propertyErrors[validation.property] = [];\n        }\n        propertyErrors[validation.property].push(...ruleErrors);\n      }\n    }\n  }\n\n  /**\n   * Applies default values to an object\n   */\n  private _applyDefaultsToObject(obj: any, _basePath: string): void {\n    for (const [propName, propDef] of Object.entries(this._schema.properties)) {\n      if (!(propName in obj) && propDef.defaultValue !== undefined) {\n        obj[propName] = propDef.defaultValue;\n      }\n    }\n  }\n}\n"]}