@snteam/amplify-angular-core 1.0.36 → 1.0.38

package/fesm2022/snteam-amplify-angular-core.mjs

@@ -1,5 +1,5 @@
 import * as i0 from '@angular/core';
-import { Component, Injectable, Pipe, inject, Input, ChangeDetectionStrategy, model, signal, EventEmitter, Output } from '@angular/core';
+import { Injectable, Component, Pipe, inject, Input, ChangeDetectionStrategy, model, signal, EventEmitter, Output } from '@angular/core';
 import * as i3$1 from '@angular/common';
 import { CommonModule } from '@angular/common';
 import * as i1 from '@angular/forms';
@@ -13,27 +13,2084 @@ import { MatSelectModule } from '@angular/material/select';
 import * as i6 from '@angular/material/datepicker';
 import { MatDatepickerModule } from '@angular/material/datepicker';
 import { provideNativeDateAdapter } from '@angular/material/core';
+import { Observable } from 'rxjs';
 import * as i3$2 from '@angular/material/divider';
 import { MatDividerModule } from '@angular/material/divider';
-import * as i2 from '@angular/material/toolbar';
+import * as i3$4 from '@angular/material/toolbar';
 import { MatToolbarModule } from '@angular/material/toolbar';
 import * as i3$3 from '@angular/material/button';
 import { MatButtonModule } from '@angular/material/button';
-import * as i4$1 from '@angular/material/icon';
+import * as i5$1 from '@angular/material/icon';
 import { MatIconModule } from '@angular/material/icon';
-import * as i5$1 from '@angular/material/list';
+import * as i6$1 from '@angular/material/list';
 import { MatListModule } from '@angular/material/list';
 import { MatDialogRef, MAT_DIALOG_DATA, MatDialogTitle, MatDialogContent, MatDialogActions, MatDialogClose, MatDialog } from '@angular/material/dialog';
 import { MatSnackBar, MatSnackBarModule } from '@angular/material/snack-bar';
-import * as i4$2 from '@angular/router';
+import * as i4$1 from '@angular/router';
 import { ActivatedRoute, Router } from '@angular/router';
 import * as i5$2 from '@angular/material/tooltip';
 import { MatTooltipModule } from '@angular/material/tooltip';
 import * as i1$1 from '@angular/material/expansion';
 import { MatExpansionModule } from '@angular/material/expansion';
-import * as i3$4 from '@angular/material/card';
+import * as i3$5 from '@angular/material/card';
 import { MatCardModule } from '@angular/material/card';
 
+// Dynamic Relationship Loader Interfaces
+
+/**
+ * Selection set generation patterns
+ */
+var SelectionSetPattern;
+(function (SelectionSetPattern) {
+    /** Basic relationship loading with id and common display fields */
+    SelectionSetPattern["BASIC"] = "basic";
+    /** Comprehensive field loading using wildcard selection */
+    SelectionSetPattern["COMPREHENSIVE"] = "comprehensive";
+    /** Selective field loading based on schema analysis */
+    SelectionSetPattern["SELECTIVE"] = "selective";
+    /** Minimal fallback pattern for error cases */
+    SelectionSetPattern["FALLBACK"] = "fallback";
+})(SelectionSetPattern || (SelectionSetPattern = {}));
+/**
+ * Field classification for display optimization
+ */
+var FieldClassification;
+(function (FieldClassification) {
+    /** Essential fields that must always be included */
+    FieldClassification["ESSENTIAL"] = "essential";
+    /** Display fields commonly shown in UI */
+    FieldClassification["DISPLAY"] = "display";
+    /** Metadata fields that provide additional context */
+    FieldClassification["METADATA"] = "metadata";
+    /** Relationship fields that link to other models */
+    FieldClassification["RELATIONSHIP"] = "relationship";
+    /** System fields used internally */
+    FieldClassification["SYSTEM"] = "system";
+    /** Unknown or unclassified fields */
+    FieldClassification["UNKNOWN"] = "unknown";
+})(FieldClassification || (FieldClassification = {}));
+
+/**
+ * Types of errors that can occur during selection set generation
+ */
+var SelectionSetErrorType;
+(function (SelectionSetErrorType) {
+    /** Configuration is invalid or incomplete */
+    SelectionSetErrorType["INVALID_CONFIGURATION"] = "invalid_configuration";
+    /** Target model not found in schema */
+    SelectionSetErrorType["MODEL_NOT_FOUND"] = "model_not_found";
+    /** Field not found in target model */
+    SelectionSetErrorType["FIELD_NOT_FOUND"] = "field_not_found";
+    /** Schema introspection data unavailable */
+    SelectionSetErrorType["SCHEMA_UNAVAILABLE"] = "schema_unavailable";
+    /** Generated selection set exceeds complexity limits */
+    SelectionSetErrorType["COMPLEXITY_EXCEEDED"] = "complexity_exceeded";
+    /** Circular reference detected in relationship chain */
+    SelectionSetErrorType["CIRCULAR_REFERENCE"] = "circular_reference";
+    /** GraphQL query failed with generated selection set */
+    SelectionSetErrorType["GRAPHQL_ERROR"] = "graphql_error";
+})(SelectionSetErrorType || (SelectionSetErrorType = {}));
+
+// Dynamic Relationship Loader Types
+
+/**
+ * Centralized error handling and logging service for the dynamic relationship loader system
+ *
+ * This service provides comprehensive error handling, logging, and recovery mechanisms
+ * for all relationship loading failures across the system.
+ */
+class ErrorHandlerService {
+    /**
+     * Maximum number of error logs to keep in memory
+     */
+    MAX_ERROR_LOGS = 100;
+    /**
+     * In-memory error log storage for debugging
+     */
+    errorLogs = [];
+    /**
+     * Error statistics for monitoring
+     */
+    errorStats = {
+        totalErrors: 0,
+        errorsByType: new Map(),
+        lastError: null,
+        recoveryAttempts: 0,
+        successfulRecoveries: 0
+    };
+    /**
+     * Log a selection set generation error with comprehensive context
+     */
+    logSelectionSetError(type, message, config, selectionSet, additionalContext) {
+        const error = {
+            type,
+            message,
+            configuration: config ? { ...config } : undefined,
+            selectionSet: selectionSet ? [...selectionSet] : undefined,
+            context: {
+                ...additionalContext,
+                userAgent: typeof navigator !== 'undefined' ? navigator.userAgent : 'unknown',
+                timestamp: new Date().toISOString(),
+                stackTrace: new Error().stack
+            },
+            timestamp: new Date()
+        };
+        // Add to error logs
+        this.addErrorLog(error);
+        // Update statistics
+        this.updateErrorStats(error);
+        // Log to console with structured format
+        this.logToConsole(error);
+        return error;
+    }
+    /**
+     * Log a GraphQL query error with retry context
+     */
+    logGraphQLError(error, config, selectionSet, retryAttempt, previousErrors = []) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return this.logSelectionSetError(SelectionSetErrorType.GRAPHQL_ERROR, `GraphQL query failed: ${errorMessage}`, config, selectionSet, {
+            originalError: {
+                message: errorMessage,
+                name: error instanceof Error ? error.name : 'Unknown',
+                stack: error instanceof Error ? error.stack : undefined
+            },
+            retryAttempt,
+            previousErrors,
+            queryContext: {
+                modelName: config.relationshipModelName,
+                fieldName: config.fieldName,
+                selectionSetLength: selectionSet.length
+            }
+        });
+    }
+    /**
+     * Log a configuration analysis error
+     */
+    logConfigurationError(config, errors, additionalContext) {
+        return this.logSelectionSetError(SelectionSetErrorType.INVALID_CONFIGURATION, `Configuration analysis failed: ${errors.join(', ')}`, config || undefined, undefined, {
+            validationErrors: errors,
+            ...additionalContext
+        });
+    }
+    /**
+     * Log a schema introspection error
+     */
+    logSchemaError(modelName, fieldName, additionalContext) {
+        const message = fieldName
+            ? `Schema validation failed for field "${fieldName}" in model "${modelName}"`
+            : `Schema data unavailable or invalid for model "${modelName}"`;
+        return this.logSelectionSetError(fieldName ? SelectionSetErrorType.FIELD_NOT_FOUND : SelectionSetErrorType.SCHEMA_UNAVAILABLE, message, undefined, undefined, {
+            modelName,
+            fieldName,
+            ...additionalContext
+        });
+    }
+    /**
+     * Log a complexity validation error
+     */
+    logComplexityError(selectionSet, validationErrors, config) {
+        return this.logSelectionSetError(SelectionSetErrorType.COMPLEXITY_EXCEEDED, `Selection set complexity exceeded limits: ${validationErrors.join(', ')}`, config, selectionSet, {
+            complexityIssues: validationErrors,
+            selectionSetSize: selectionSet.length,
+            maxDepth: Math.max(...selectionSet.map(s => (s.match(/\./g) || []).length))
+        });
+    }
+    /**
+     * Log a circular reference error
+     */
+    logCircularReferenceError(circularPath, selectionSet, config) {
+        return this.logSelectionSetError(SelectionSetErrorType.CIRCULAR_REFERENCE, `Circular reference detected in path: ${circularPath}`, config, selectionSet, {
+            circularPath,
+            pathDepth: circularPath.split('.').length
+        });
+    }
+    /**
+     * Log a successful error recovery
+     */
+    logSuccessfulRecovery(originalError, recoveryMethod, finalSelectionSet) {
+        this.errorStats.recoveryAttempts++;
+        this.errorStats.successfulRecoveries++;
+        console.log('ErrorHandler: Successful error recovery:', {
+            originalError: {
+                type: originalError.type,
+                message: originalError.message
+            },
+            recoveryMethod,
+            finalSelectionSet,
+            recoveryRate: this.getRecoveryRate(),
+            timestamp: new Date().toISOString()
+        });
+    }
+    /**
+     * Log a failed error recovery attempt
+     */
+    logFailedRecovery(originalError, recoveryAttempts, finalError) {
+        this.errorStats.recoveryAttempts++;
+        const failureError = this.logSelectionSetError(SelectionSetErrorType.GRAPHQL_ERROR, `All recovery attempts failed: ${finalError instanceof Error ? finalError.message : String(finalError)}`, originalError.configuration, originalError.selectionSet, {
+            originalError: {
+                type: originalError.type,
+                message: originalError.message
+            },
+            recoveryAttempts,
+            finalError: {
+                message: finalError instanceof Error ? finalError.message : String(finalError),
+                type: typeof finalError
+            },
+            recoveryRate: this.getRecoveryRate()
+        });
+        console.error('ErrorHandler: All recovery attempts failed:', failureError);
+    }
+    /**
+     * Create a SelectionSetResult for a successful operation
+     */
+    createSuccessResult(selectionSet, patternUsed, usedFallback = false) {
+        return {
+            success: true,
+            selectionSet: [...selectionSet],
+            usedFallback,
+            patternUsed
+        };
+    }
+    /**
+     * Create a SelectionSetResult for a failed operation
+     */
+    createErrorResult(error) {
+        return {
+            success: false,
+            error,
+            usedFallback: false
+        };
+    }
+    /**
+     * Get error statistics for monitoring and debugging
+     */
+    getErrorStats() {
+        const errorsByType = {};
+        this.errorStats.errorsByType.forEach((count, type) => {
+            errorsByType[type] = count;
+        });
+        return {
+            totalErrors: this.errorStats.totalErrors,
+            errorsByType,
+            lastError: this.errorStats.lastError,
+            recoveryAttempts: this.errorStats.recoveryAttempts,
+            successfulRecoveries: this.errorStats.successfulRecoveries,
+            recoveryRate: this.getRecoveryRate(),
+            recentErrors: this.getRecentErrors(10)
+        };
+    }
+    /**
+     * Get recent error logs for debugging
+     */
+    getRecentErrors(count = 10) {
+        return this.errorLogs
+            .slice(-count)
+            .sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+    }
+    /**
+     * Clear all error logs and reset statistics
+     */
+    clearErrorLogs() {
+        this.errorLogs = [];
+        this.errorStats = {
+            totalErrors: 0,
+            errorsByType: new Map(),
+            lastError: null,
+            recoveryAttempts: 0,
+            successfulRecoveries: 0
+        };
+        console.log('ErrorHandler: Error logs and statistics cleared');
+    }
+    /**
+     * Check if the system is experiencing high error rates
+     */
+    isHighErrorRate(timeWindowMinutes = 5, threshold = 10) {
+        const cutoffTime = new Date(Date.now() - timeWindowMinutes * 60 * 1000);
+        const recentErrors = this.errorLogs.filter(error => error.timestamp > cutoffTime);
+        return recentErrors.length >= threshold;
+    }
+    /**
+     * Get error patterns for analysis
+     */
+    getErrorPatterns() {
+        if (this.errorLogs.length === 0) {
+            return {
+                mostCommonErrorType: null,
+                mostProblematicModel: null,
+                mostProblematicField: null,
+                errorTrends: []
+            };
+        }
+        // Find most common error type
+        let mostCommonErrorType = null;
+        let maxErrorCount = 0;
+        this.errorStats.errorsByType.forEach((count, type) => {
+            if (count > maxErrorCount) {
+                maxErrorCount = count;
+                mostCommonErrorType = type;
+            }
+        });
+        // Find most problematic model
+        const modelCounts = new Map();
+        this.errorLogs.forEach(error => {
+            if (error.configuration?.relationshipModelName) {
+                const count = modelCounts.get(error.configuration.relationshipModelName) || 0;
+                modelCounts.set(error.configuration.relationshipModelName, count + 1);
+            }
+        });
+        let mostProblematicModel = null;
+        let maxModelCount = 0;
+        modelCounts.forEach((count, model) => {
+            if (count > maxModelCount) {
+                maxModelCount = count;
+                mostProblematicModel = model;
+            }
+        });
+        // Find most problematic field
+        const fieldCounts = new Map();
+        this.errorLogs.forEach(error => {
+            if (error.configuration?.fieldName) {
+                const count = fieldCounts.get(error.configuration.fieldName) || 0;
+                fieldCounts.set(error.configuration.fieldName, count + 1);
+            }
+        });
+        let mostProblematicField = null;
+        let maxFieldCount = 0;
+        fieldCounts.forEach((count, field) => {
+            if (count > maxFieldCount) {
+                maxFieldCount = count;
+                mostProblematicField = field;
+            }
+        });
+        // Generate error trends by hour
+        const hourCounts = new Map();
+        this.errorLogs.forEach(error => {
+            const hour = error.timestamp.toISOString().substring(0, 13); // YYYY-MM-DDTHH
+            const count = hourCounts.get(hour) || 0;
+            hourCounts.set(hour, count + 1);
+        });
+        const errorTrends = Array.from(hourCounts.entries())
+            .map(([hour, errorCount]) => ({ hour, errorCount }))
+            .sort((a, b) => a.hour.localeCompare(b.hour));
+        return {
+            mostCommonErrorType,
+            mostProblematicModel,
+            mostProblematicField,
+            errorTrends
+        };
+    }
+    /**
+     * Add error to the log with size management
+     */
+    addErrorLog(error) {
+        this.errorLogs.push(error);
+        // Maintain maximum log size
+        if (this.errorLogs.length > this.MAX_ERROR_LOGS) {
+            this.errorLogs = this.errorLogs.slice(-this.MAX_ERROR_LOGS);
+        }
+    }
+    /**
+     * Update error statistics
+     */
+    updateErrorStats(error) {
+        this.errorStats.totalErrors++;
+        this.errorStats.lastError = error;
+        const currentCount = this.errorStats.errorsByType.get(error.type) || 0;
+        this.errorStats.errorsByType.set(error.type, currentCount + 1);
+    }
+    /**
+     * Calculate recovery rate percentage
+     */
+    getRecoveryRate() {
+        if (this.errorStats.recoveryAttempts === 0) {
+            return 0;
+        }
+        return Math.round((this.errorStats.successfulRecoveries / this.errorStats.recoveryAttempts) * 100);
+    }
+    /**
+     * Log error to console with structured format
+     */
+    logToConsole(error) {
+        const logData = {
+            type: error.type,
+            message: error.message,
+            timestamp: error.timestamp.toISOString(),
+            configuration: error.configuration ? {
+                relationshipModel: error.configuration.relationshipModelName,
+                baseModel: error.configuration.baseModelName,
+                fieldName: error.configuration.fieldName,
+                associatedWith: error.configuration.associatedWith
+            } : undefined,
+            selectionSet: error.selectionSet,
+            context: error.context
+        };
+        // Use appropriate console method based on error severity
+        switch (error.type) {
+            case SelectionSetErrorType.INVALID_CONFIGURATION:
+            case SelectionSetErrorType.GRAPHQL_ERROR:
+                console.error('ErrorHandler: Critical error:', logData);
+                break;
+            case SelectionSetErrorType.SCHEMA_UNAVAILABLE:
+            case SelectionSetErrorType.MODEL_NOT_FOUND:
+            case SelectionSetErrorType.FIELD_NOT_FOUND:
+                console.warn('ErrorHandler: Schema-related warning:', logData);
+                break;
+            case SelectionSetErrorType.COMPLEXITY_EXCEEDED:
+            case SelectionSetErrorType.CIRCULAR_REFERENCE:
+                console.warn('ErrorHandler: Complexity warning:', logData);
+                break;
+            default:
+                console.log('ErrorHandler: General error:', logData);
+                break;
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: ErrorHandlerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: ErrorHandlerService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: ErrorHandlerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+/**
+ * Service for analyzing relationship configurations to extract field mappings
+ *
+ * This service analyzes relationship configurations to determine target models
+ * and generate appropriate field selectors for GraphQL queries.
+ */
+class ConfigurationAnalyzerService {
+    errorHandler;
+    /**
+     * Common display field names to look for in models
+     */
+    COMMON_DISPLAY_FIELDS = ['name', 'title', 'label', 'displayName', 'description'];
+    constructor(errorHandler) {
+        this.errorHandler = errorHandler;
+    }
+    /**
+     * Analyze a relationship configuration to extract field mappings and validate structure
+     * Enhanced with comprehensive error handling and logging
+     */
+    analyzeConfiguration(config) {
+        const errors = [];
+        try {
+            // Validate configuration completeness
+            if (!config) {
+                const error = 'Configuration is null or undefined';
+                errors.push(error);
+                this.errorHandler.logConfigurationError(null, [error], {
+                    method: 'analyzeConfiguration',
+                    step: 'initial_validation'
+                });
+                return {
+                    targetModelName: '',
+                    fieldSelectors: [],
+                    isValid: false,
+                    errors
+                };
+            }
+            // Validate required fields
+            const requiredFields = [
+                { field: 'relationshipModelName', value: config.relationshipModelName },
+                { field: 'baseModelName', value: config.baseModelName },
+                { field: 'fieldName', value: config.fieldName },
+                { field: 'associatedWith', value: config.associatedWith }
+            ];
+            for (const { field, value } of requiredFields) {
+                if (!value) {
+                    errors.push(`${field} is required`);
+                }
+            }
+            if (errors.length > 0) {
+                this.errorHandler.logConfigurationError(config, errors, {
+                    method: 'analyzeConfiguration',
+                    step: 'field_validation',
+                    providedFields: {
+                        relationshipModelName: !!config.relationshipModelName,
+                        baseModelName: !!config.baseModelName,
+                        fieldName: !!config.fieldName,
+                        associatedWith: !!config.associatedWith
+                    }
+                });
+                return {
+                    targetModelName: '',
+                    fieldSelectors: [],
+                    isValid: false,
+                    errors
+                };
+            }
+            // Extract target model name from the configuration
+            const targetModelName = this.extractTargetModelName(config);
+            if (!targetModelName) {
+                const error = 'Could not determine target model name from configuration';
+                errors.push(error);
+                this.errorHandler.logConfigurationError(config, [error], {
+                    method: 'analyzeConfiguration',
+                    step: 'target_model_extraction',
+                    fieldName: config.fieldName
+                });
+                return {
+                    targetModelName: '',
+                    fieldSelectors: [],
+                    isValid: false,
+                    errors
+                };
+            }
+            // Generate field selectors for the target model
+            const fieldSelectors = this.determineFieldSelectorsEnhanced(targetModelName, config.fieldName);
+            if (!fieldSelectors || fieldSelectors.length === 0) {
+                const error = 'Could not generate field selectors for target model';
+                errors.push(error);
+                this.errorHandler.logConfigurationError(config, [error], {
+                    method: 'analyzeConfiguration',
+                    step: 'field_selector_generation',
+                    targetModelName,
+                    fieldName: config.fieldName
+                });
+                return {
+                    targetModelName,
+                    fieldSelectors: [],
+                    isValid: false,
+                    errors
+                };
+            }
+            console.log('ConfigurationAnalyzer: Successfully analyzed configuration:', {
+                targetModelName,
+                fieldSelectorsCount: fieldSelectors.length,
+                fieldName: config.fieldName
+            });
+            return {
+                targetModelName,
+                fieldSelectors,
+                isValid: true,
+                errors: []
+            };
+        }
+        catch (error) {
+            const errorMessage = `Analysis failed: ${error instanceof Error ? error.message : String(error)}`;
+            errors.push(errorMessage);
+            this.errorHandler.logSelectionSetError(SelectionSetErrorType.INVALID_CONFIGURATION, errorMessage, config, undefined, {
+                method: 'analyzeConfiguration',
+                step: 'exception_handling',
+                originalError: {
+                    message: error instanceof Error ? error.message : String(error),
+                    stack: error instanceof Error ? error.stack : undefined,
+                    type: typeof error
+                }
+            });
+            return {
+                targetModelName: '',
+                fieldSelectors: [],
+                isValid: false,
+                errors
+            };
+        }
+    }
+    /**
+     * Extract the target model name from a relationship configuration
+     * Enhanced with error handling and validation
+     *
+     * For a FormViewField relationship, this would extract the target model
+     * that we want to display (e.g., "Field" from the FormViewField junction)
+     */
+    extractTargetModelName(config) {
+        try {
+            if (!config || !config.fieldName) {
+                this.errorHandler.logSelectionSetError(SelectionSetErrorType.INVALID_CONFIGURATION, 'Cannot extract target model name: configuration or fieldName is missing', config, undefined, {
+                    method: 'extractTargetModelName',
+                    hasConfig: !!config,
+                    hasFieldName: !!(config?.fieldName)
+                });
+                return '';
+            }
+            // The fieldName typically corresponds to the target model we want to access
+            // For example, if fieldName is "formView", the target model is "FormView"
+            // If fieldName is "service", the target model is "Service"
+            // Convert fieldName to PascalCase to match Amplify model naming conventions
+            const targetModelName = this.toPascalCase(config.fieldName);
+            if (!targetModelName) {
+                this.errorHandler.logSelectionSetError(SelectionSetErrorType.INVALID_CONFIGURATION, 'Failed to convert fieldName to PascalCase for target model name', config, undefined, {
+                    method: 'extractTargetModelName',
+                    fieldName: config.fieldName,
+                    conversionResult: targetModelName
+                });
+                return '';
+            }
+            console.log(`ConfigurationAnalyzer: Extracted target model name "${targetModelName}" from field "${config.fieldName}"`);
+            return targetModelName;
+        }
+        catch (error) {
+            this.errorHandler.logSelectionSetError(SelectionSetErrorType.INVALID_CONFIGURATION, `Error extracting target model name: ${error instanceof Error ? error.message : String(error)}`, config, undefined, {
+                method: 'extractTargetModelName',
+                originalError: {
+                    message: error instanceof Error ? error.message : String(error),
+                    stack: error instanceof Error ? error.stack : undefined
+                }
+            });
+            return '';
+        }
+    }
+    /**
+     * Determine appropriate field selectors for a target model
+     *
+     * This generates GraphQL field selectors that include the relationship field
+     * and common display properties like id, name, title, etc.
+     */
+    determineFieldSelectors(targetModel) {
+        if (!targetModel) {
+            return [];
+        }
+        const selectors = [];
+        // Always include the base record ID
+        selectors.push('id');
+        // Convert target model to camelCase for field access
+        const fieldName = this.toCamelCase(targetModel);
+        // Add the relationship field itself (this is important for validation)
+        selectors.push(fieldName);
+        // Add the relationship field with its ID
+        selectors.push(`${fieldName}.id`);
+        // Add common display fields for the relationship
+        for (const displayField of this.COMMON_DISPLAY_FIELDS) {
+            selectors.push(`${fieldName}.${displayField}`);
+        }
+        return selectors;
+    }
+    /**
+     * Parse and validate nested relationship paths
+     *
+     * Handles complex relationship configurations like "formView.user.profile"
+     * and validates for circular references
+     */
+    parseNestedRelationshipPath(fieldName, maxDepth = 3) {
+        if (!fieldName) {
+            return [];
+        }
+        // Split the field name by dots to handle nested paths
+        const pathSegments = fieldName.split('.');
+        // Limit nesting depth to prevent overly complex queries
+        if (pathSegments.length > maxDepth) {
+            console.warn(`ConfigurationAnalyzer: Nested relationship path "${fieldName}" exceeds maximum depth of ${maxDepth}. Truncating.`);
+            pathSegments.splice(maxDepth);
+        }
+        // Check for circular references (same segment appearing multiple times)
+        const uniqueSegments = new Set(pathSegments);
+        if (uniqueSegments.size !== pathSegments.length) {
+            console.warn(`ConfigurationAnalyzer: Circular reference detected in path "${fieldName}". Using only unique segments.`);
+            return Array.from(uniqueSegments);
+        }
+        return pathSegments;
+    }
+    /**
+     * Generate field selectors for nested relationship paths
+     *
+     * Creates GraphQL selectors that can handle nested relationships
+     * like "formView.user.profile.name"
+     */
+    generateNestedFieldSelectors(fieldName, targetModel) {
+        const pathSegments = this.parseNestedRelationshipPath(fieldName);
+        const selectors = [];
+        // Always include the base record ID
+        selectors.push('id');
+        if (pathSegments.length === 0) {
+            return selectors;
+        }
+        // For single-level relationships, use the existing logic
+        if (pathSegments.length === 1) {
+            const camelCaseField = this.toCamelCase(pathSegments[0]);
+            selectors.push(`${camelCaseField}.id`);
+            // Add common display fields
+            for (const displayField of this.COMMON_DISPLAY_FIELDS) {
+                selectors.push(`${camelCaseField}.${displayField}`);
+            }
+            return selectors;
+        }
+        // For nested relationships, build the path progressively
+        let currentPath = '';
+        for (let i = 0; i < pathSegments.length; i++) {
+            const segment = this.toCamelCase(pathSegments[i]);
+            if (i === 0) {
+                currentPath = segment;
+            }
+            else {
+                currentPath += `.${segment}`;
+            }
+            // Add ID for each level
+            selectors.push(`${currentPath}.id`);
+            // Add display fields only for the final level to avoid overly complex queries
+            if (i === pathSegments.length - 1) {
+                for (const displayField of this.COMMON_DISPLAY_FIELDS) {
+                    selectors.push(`${currentPath}.${displayField}`);
+                }
+            }
+        }
+        return selectors;
+    }
+    /**
+     * Enhanced field selector determination that supports nested paths and handles different relationship types
+     */
+    determineFieldSelectorsEnhanced(targetModel, fieldName) {
+        if (!targetModel) {
+            return [];
+        }
+        // If no specific field name provided, use the target model name
+        const effectiveFieldName = fieldName || this.toCamelCase(targetModel);
+        // Check if this is a nested relationship path
+        if (effectiveFieldName.includes('.')) {
+            return this.generateNestedFieldSelectors(effectiveFieldName, targetModel);
+        }
+        // Generate selectors for the relationship
+        const selectors = [];
+        // Always include the base record ID
+        selectors.push('id');
+        // For the relationship field, we need to be more flexible about how we include it
+        // Some relationships might need the field itself, others might need nested access
+        // Strategy 1: Include the relationship field directly
+        selectors.push(effectiveFieldName);
+        // Strategy 2: Include nested access to common fields
+        selectors.push(`${effectiveFieldName}.id`);
+        // Add common display fields for the relationship
+        for (const displayField of this.COMMON_DISPLAY_FIELDS) {
+            selectors.push(`${effectiveFieldName}.${displayField}`);
+        }
+        // Strategy 3: For some relationship types, we might need to include additional metadata
+        // Add some common relationship metadata fields
+        const metadataFields = ['createdAt', 'updatedAt'];
+        for (const metadataField of metadataFields) {
+            selectors.push(`${effectiveFieldName}.${metadataField}`);
+        }
+        console.log(`ConfigurationAnalyzer: Generated ${selectors.length} field selectors for ${targetModel} with field ${effectiveFieldName}:`, selectors);
+        return selectors;
+    }
+    /**
+     * Convert a string to PascalCase (first letter uppercase, rest camelCase)
+     */
+    toPascalCase(str) {
+        if (!str)
+            return '';
+        // Handle camelCase to PascalCase
+        return str.charAt(0).toUpperCase() + str.slice(1);
+    }
+    /**
+     * Convert a string to camelCase (first letter lowercase)
+     */
+    toCamelCase(str) {
+        if (!str)
+            return '';
+        // Handle PascalCase to camelCase
+        return str.charAt(0).toLowerCase() + str.slice(1);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: ConfigurationAnalyzerService, deps: [{ token: ErrorHandlerService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: ConfigurationAnalyzerService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: ConfigurationAnalyzerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: ErrorHandlerService }] });
+
+/**
+ * Service for introspecting Amplify schema data to validate and enhance selection sets
+ *
+ * This service leverages Amplify's schema introspection data to validate field existence,
+ * extract model information, and provide schema-aware field selection for GraphQL queries.
+ */
+class SchemaIntrospectorService {
+    errorHandler;
+    amplifyOutputs = null;
+    /**
+     * Common display field names that are typically used for showing model data
+     */
+    COMMON_DISPLAY_FIELDS = ['name', 'title', 'label', 'displayName', 'description'];
+    /**
+     * System fields that are typically not used for display
+     */
+    SYSTEM_FIELDS = ['id', 'createdAt', 'updatedAt', 'owner'];
+    constructor(errorHandler) {
+        this.errorHandler = errorHandler;
+    }
+    /**
+     * Initialize the service with Amplify outputs data
+     * Enhanced with error handling and validation
+     * This should be called by consuming applications to provide schema data
+     */
+    initializeSchema(amplifyOutputs) {
+        try {
+            if (!amplifyOutputs) {
+                this.errorHandler.logSchemaError('', undefined, {
+                    method: 'initializeSchema',
+                    error: 'amplifyOutputs is null or undefined'
+                });
+                console.warn('SchemaIntrospectorService: Cannot initialize with null or undefined amplifyOutputs');
+                return;
+            }
+            // Validate schema structure
+            if (!amplifyOutputs.data || !amplifyOutputs.data.model_introspection || !amplifyOutputs.data.model_introspection.models) {
+                this.errorHandler.logSchemaError('', undefined, {
+                    method: 'initializeSchema',
+                    error: 'Invalid schema structure',
+                    hasData: !!amplifyOutputs.data,
+                    hasModelIntrospection: !!(amplifyOutputs.data?.model_introspection),
+                    hasModels: !!(amplifyOutputs.data?.model_introspection?.models)
+                });
+                console.warn('SchemaIntrospectorService: Invalid schema structure in amplifyOutputs');
+                return;
+            }
+            this.amplifyOutputs = amplifyOutputs;
+            const modelCount = Object.keys(amplifyOutputs.data.model_introspection.models).length;
+            console.log(`SchemaIntrospectorService: Successfully initialized with schema data (${modelCount} models)`);
+        }
+        catch (error) {
+            this.errorHandler.logSelectionSetError(SelectionSetErrorType.SCHEMA_UNAVAILABLE, `Error initializing schema: ${error instanceof Error ? error.message : String(error)}`, undefined, undefined, {
+                method: 'initializeSchema',
+                originalError: {
+                    message: error instanceof Error ? error.message : String(error),
+                    stack: error instanceof Error ? error.stack : undefined
+                }
+            });
+            console.error('SchemaIntrospectorService: Error initializing schema:', error);
+        }
+    }
+    /**
+     * Get field information for a specific model from the schema
+     * Enhanced with comprehensive error handling and logging
+     */
+    getModelFields(modelName) {
+        try {
+            if (!this.isSchemaAvailable()) {
+                this.errorHandler.logSchemaError(modelName, undefined, {
+                    method: 'getModelFields',
+                    error: 'Schema data not available'
+                });
+                console.warn('SchemaIntrospectorService: Schema data not available');
+                return [];
+            }
+            if (!modelName) {
+                this.errorHandler.logSchemaError('', undefined, {
+                    method: 'getModelFields',
+                    error: 'Model name is empty or undefined'
+                });
+                return [];
+            }
+            const models = this.amplifyOutputs.data.model_introspection.models;
+            const modelData = models[modelName];
+            if (!modelData) {
+                this.errorHandler.logSchemaError(modelName, undefined, {
+                    method: 'getModelFields',
+                    error: 'Model not found in schema',
+                    availableModels: Object.keys(models)
+                });
+                console.warn(`SchemaIntrospectorService: Model "${modelName}" not found in schema`);
+                return [];
+            }
+            if (!modelData.fields) {
+                this.errorHandler.logSchemaError(modelName, undefined, {
+                    method: 'getModelFields',
+                    error: 'Model has no fields property',
+                    modelData: Object.keys(modelData)
+                });
+                console.warn(`SchemaIntrospectorService: Model "${modelName}" has no fields`);
+                return [];
+            }
+            const fields = [];
+            const fieldValues = Object.values(modelData.fields);
+            for (const field of fieldValues) {
+                try {
+                    const fieldData = field;
+                    if (!fieldData.name) {
+                        console.warn(`SchemaIntrospectorService: Field in model "${modelName}" has no name property`);
+                        continue;
+                    }
+                    fields.push({
+                        name: fieldData.name,
+                        type: this.determineFieldType(fieldData.type),
+                        isRequired: fieldData.isRequired || false,
+                        isRelationship: this.isRelationshipField(fieldData)
+                    });
+                }
+                catch (fieldError) {
+                    console.warn(`SchemaIntrospectorService: Error processing field in model "${modelName}":`, fieldError);
+                    // Continue processing other fields
+                }
+            }
+            console.log(`SchemaIntrospectorService: Retrieved ${fields.length} fields for model "${modelName}"`);
+            return fields;
+        }
+        catch (error) {
+            this.errorHandler.logSelectionSetError(SelectionSetErrorType.MODEL_NOT_FOUND, `Error getting fields for model "${modelName}": ${error instanceof Error ? error.message : String(error)}`, undefined, undefined, {
+                method: 'getModelFields',
+                modelName,
+                originalError: {
+                    message: error instanceof Error ? error.message : String(error),
+                    stack: error instanceof Error ? error.stack : undefined
+                }
+            });
+            console.error(`SchemaIntrospectorService: Error getting fields for model "${modelName}":`, error);
+            return [];
+        }
+    }
+    /**
+     * Validate that a specific field exists in a model
+     */
+    validateFieldExists(modelName, fieldName) {
+        if (!this.isSchemaAvailable() || !modelName || !fieldName) {
+            return false;
+        }
+        try {
+            const models = this.amplifyOutputs.data.model_introspection.models;
+            const modelData = models[modelName];
+            if (!modelData || !modelData.fields) {
+                return false;
+            }
+            return fieldName in modelData.fields;
+        }
+        catch (error) {
+            console.error(`SchemaIntrospectorService: Error validating field "${fieldName}" in model "${modelName}":`, error);
+            return false;
+        }
+    }
+    /**
+     * Get common display fields for a model (e.g., name, title, label)
+     */
+    getCommonDisplayFields(modelName) {
+        if (!this.isSchemaAvailable()) {
+            // Fallback: return conservative display fields when schema is unavailable
+            return this.getConservativeDisplayFields(modelName);
+        }
+        const modelFields = this.getModelFields(modelName);
+        const displayFields = [];
+        // Always include id for relationships
+        if (this.validateFieldExists(modelName, 'id')) {
+            displayFields.push('id');
+        }
+        // Look for common display fields in the model
+        for (const commonField of this.COMMON_DISPLAY_FIELDS) {
+            const field = modelFields.find(f => f.name === commonField);
+            if (field && !field.isRelationship) {
+                displayFields.push(commonField);
+            }
+        }
+        // If no common display fields found, include the first non-system, non-relationship field
+        if (displayFields.length <= 1) { // Only id was added
+            const firstDisplayField = modelFields.find(f => !this.SYSTEM_FIELDS.includes(f.name) &&
+                !f.isRelationship &&
+                f.type === 'string');
+            if (firstDisplayField && !displayFields.includes(firstDisplayField.name)) {
+                displayFields.push(firstDisplayField.name);
+            }
+        }
+        return displayFields;
+    }
+    /**
+     * Check if schema introspection data is available
+     */
+    isSchemaAvailable() {
+        return !!(this.amplifyOutputs &&
+            this.amplifyOutputs.data &&
+            this.amplifyOutputs.data.model_introspection &&
+            this.amplifyOutputs.data.model_introspection.models);
+    }
+    /**
+     * Get conservative display fields when schema data is unavailable
+     * This provides a safe fallback that works with most Amplify models
+     */
+    getConservativeDisplayFields(modelName) {
+        console.warn(`SchemaIntrospectorService: Schema unavailable, using conservative display fields for model "${modelName}"`);
+        // Return a conservative set of fields that are commonly available
+        const conservativeFields = ['id'];
+        // Add all common display field names - the GraphQL query will simply ignore non-existent fields
+        conservativeFields.push(...this.COMMON_DISPLAY_FIELDS);
+        return conservativeFields;
+    }
+    /**
+     * Get model fields with fallback behavior when schema is unavailable
+     */
+    getModelFieldsWithFallback(modelName) {
+        if (this.isSchemaAvailable()) {
+            return this.getModelFields(modelName);
+        }
+        // Fallback: return conservative field set
+        console.warn(`SchemaIntrospectorService: Schema unavailable, using conservative field set for model "${modelName}"`);
+        const conservativeFields = [
+            { name: 'id', type: 'id', isRequired: true, isRelationship: false }
+        ];
+        // Add common display fields as optional string fields
+        for (const fieldName of this.COMMON_DISPLAY_FIELDS) {
+            conservativeFields.push({
+                name: fieldName,
+                type: 'string',
+                isRequired: false,
+                isRelationship: false
+            });
+        }
+        return conservativeFields;
+    }
+    /**
+     * Validate field existence with fallback behavior
+     * When schema is unavailable, assumes common fields exist
+     */
+    validateFieldExistsWithFallback(modelName, fieldName) {
+        if (this.isSchemaAvailable()) {
+            return this.validateFieldExists(modelName, fieldName);
+        }
+        // Fallback: assume common fields exist
+        const commonFields = ['id', ...this.COMMON_DISPLAY_FIELDS];
+        const fieldExists = commonFields.includes(fieldName);
+        if (!fieldExists) {
+            console.warn(`SchemaIntrospectorService: Schema unavailable, cannot validate field "${fieldName}" in model "${modelName}". Assuming it does not exist.`);
+        }
+        return fieldExists;
+    }
+    /**
+     * Get safe field selectors that work even when schema data is unavailable
+     * This method prioritizes reliability over completeness
+     */
+    getSafeFieldSelectors(modelName, fieldName) {
+        const selectors = ['id']; // Always safe to include
+        if (!fieldName) {
+            return selectors;
+        }
+        // Add the relationship field with id (safe even if field doesn't exist)
+        selectors.push(`${fieldName}.id`);
+        if (this.isSchemaAvailable()) {
+            // Use schema-aware field selection
+            const displayFields = this.getCommonDisplayFields(modelName);
+            for (const displayField of displayFields) {
+                if (displayField !== 'id') { // Already added
+                    selectors.push(`${fieldName}.${displayField}`);
+                }
+            }
+        }
+        else {
+            // Use conservative field selection
+            const conservativeFields = this.getConservativeDisplayFields(modelName);
+            for (const conservativeField of conservativeFields) {
+                if (conservativeField !== 'id') { // Already added
+                    selectors.push(`${fieldName}.${conservativeField}`);
+                }
+            }
+        }
+        return selectors;
+    }
+    /**
+     * Get schema status information for debugging
+     */
+    getSchemaStatus() {
+        const status = {
+            isAvailable: this.isSchemaAvailable(),
+            modelCount: 0,
+            availableModels: [],
+            lastError: undefined
+        };
+        if (status.isAvailable) {
+            try {
+                status.availableModels = this.getAvailableModels();
+                status.modelCount = status.availableModels.length;
+            }
+            catch (error) {
+                status.lastError = error instanceof Error ? error.message : String(error);
+            }
+        }
+        else {
+            status.lastError = 'Schema data not available or invalid structure';
+        }
+        return status;
+    }
+    /**
+     * Get all available model names from the schema
+     */
+    getAvailableModels() {
+        if (!this.isSchemaAvailable()) {
+            return [];
+        }
+        try {
+            return Object.keys(this.amplifyOutputs.data.model_introspection.models);
+        }
+        catch (error) {
+            console.error('SchemaIntrospectorService: Error getting available models:', error);
+            return [];
+        }
+    }
+    /**
+     * Get detailed information about a specific model
+     */
+    getModelInfo(modelName) {
+        if (!this.isSchemaAvailable() || !modelName) {
+            return null;
+        }
+        try {
+            const models = this.amplifyOutputs.data.model_introspection.models;
+            return models[modelName] || null;
+        }
+        catch (error) {
+            console.error(`SchemaIntrospectorService: Error getting model info for "${modelName}":`, error);
+            return null;
+        }
+    }
+    /**
+     * Determine the simplified type of a field from Amplify schema data
+     */
+    determineFieldType(fieldType) {
+        if (typeof fieldType === 'string') {
+            return fieldType.toLowerCase();
+        }
+        if (typeof fieldType === 'object') {
+            if (fieldType.model) {
+                return 'relationship';
+            }
+            if (fieldType.enum) {
+                return 'enum';
+            }
+        }
+        return 'unknown';
+    }
+    /**
+     * Check if a field represents a relationship to another model
+     */
+    isRelationshipField(fieldData) {
+        return !!(fieldData.type &&
+            typeof fieldData.type === 'object' &&
+            fieldData.type.model);
+    }
+    /**
+     * Get relationship information for a field
+     */
+    getRelationshipInfo(modelName, fieldName) {
+        if (!this.validateFieldExists(modelName, fieldName)) {
+            return null;
+        }
+        try {
+            const models = this.amplifyOutputs.data.model_introspection.models;
+            const modelData = models[modelName];
+            const fieldData = modelData.fields[fieldName];
+            if (!this.isRelationshipField(fieldData)) {
+                return null;
+            }
+            return {
+                targetModel: fieldData.type.model,
+                connectionType: fieldData.association?.connectionType,
+                associatedWith: fieldData.association?.associatedWith,
+                targetNames: fieldData.association?.targetNames
+            };
+        }
+        catch (error) {
+            console.error(`SchemaIntrospectorService: Error getting relationship info for "${modelName}.${fieldName}":`, error);
+            return null;
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: SchemaIntrospectorService, deps: [{ token: ErrorHandlerService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: SchemaIntrospectorService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: SchemaIntrospectorService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: ErrorHandlerService }] });
+
+/**
+ * Service for generating dynamic GraphQL selection sets for Amplify relationships
+ *
+ * This service replaces hardcoded selection set logic with dynamic generation
+ * based on relationship configurations, schema introspection, and intelligent caching.
+ */
+class SelectionSetGeneratorService {
+    configurationAnalyzer;
+    schemaIntrospector;
+    errorHandler;
+    /**
+     * Cache for generated selection sets to improve performance
+     */
+    selectionSetCache = new Map();
+    /**
+     * Default configuration for selection set generation
+     */
+    DEFAULT_CONFIG = {
+        pattern: SelectionSetPattern.SELECTIVE,
+        maxDepth: 3,
+        maxFields: 10,
+        validateWithSchema: true,
+        requiredFields: ['id'],
+        complexityLimits: {
+            maxNestingDepth: 3,
+            maxFieldCount: 20,
+            maxWildcardSelections: 2,
+            preventCircularReferences: true,
+            maxSelectorLength: 100
+        }
+    };
+    /**
+     * Default display optimization configuration
+     */
+    DEFAULT_DISPLAY_CONFIG = {
+        enabled: true,
+        commonDisplayFields: ['id', 'name', 'title', 'label', 'displayName', 'description'],
+        excludeFromOptimization: ['id', 'createdAt', 'updatedAt'],
+        prioritizeDisplayFields: true,
+        maxNonDisplayFields: 5
+    };
+    constructor(configurationAnalyzer, schemaIntrospector, errorHandler) {
+        this.configurationAnalyzer = configurationAnalyzer;
+        this.schemaIntrospector = schemaIntrospector;
+        this.errorHandler = errorHandler;
+    }
+    /**
+     * Generate a selection set for a given relationship configuration
+     * Enhanced with comprehensive error handling and logging
+     */
+    generateSelectionSet(config) {
+        try {
+            // Validate input configuration
+            if (!config) {
+                const error = this.errorHandler.logSelectionSetError(SelectionSetErrorType.INVALID_CONFIGURATION, 'Configuration is null or undefined', config);
+                return this.handleGenerationError(error, '');
+            }
+            // Check cache first
+            const cacheKey = this.generateCacheKey(config);
+            const cached = this.getCachedSelectionSet(cacheKey);
+            if (cached) {
+                console.log('SelectionSetGenerator: Using cached selection set for config:', config.fieldName);
+                return cached.selectionSet;
+            }
+            // Analyze the configuration
+            const analysisResult = this.configurationAnalyzer.analyzeConfiguration(config);
+            if (!analysisResult || !analysisResult.isValid) {
+                const errors = analysisResult?.errors || ['Invalid configuration'];
+                const error = this.errorHandler.logConfigurationError(config, errors, {
+                    analysisResult,
+                    cacheKey
+                });
+                return this.handleGenerationError(error, config.fieldName);
+            }
+            // Generate selection set based on analysis and schema availability
+            const selectionSet = this.generateSelectionSetFromAnalysis(config, analysisResult);
+            // Validate the generated selection set
+            if (!this.validateSelectionSet(selectionSet)) {
+                const error = this.errorHandler.logSelectionSetError(SelectionSetErrorType.INVALID_CONFIGURATION, 'Generated selection set failed validation', config, selectionSet, { analysisResult });
+                return this.handleGenerationError(error, config.fieldName);
+            }
+            // Cache the result
+            this.cacheSelectionSet(cacheKey, selectionSet);
+            console.log('SelectionSetGenerator: Successfully generated selection set:', {
+                config: config.fieldName,
+                selectionSetLength: selectionSet.length,
+                selectionSet
+            });
+            return selectionSet;
+        }
+        catch (error) {
+            const selectionSetError = this.errorHandler.logSelectionSetError(SelectionSetErrorType.GRAPHQL_ERROR, `Unexpected error during selection set generation: ${error instanceof Error ? error.message : String(error)}`, config, undefined, {
+                originalError: {
+                    message: error instanceof Error ? error.message : String(error),
+                    stack: error instanceof Error ? error.stack : undefined,
+                    type: typeof error
+                }
+            });
+            return this.handleGenerationError(selectionSetError, config?.fieldName || '');
+        }
+    }
+    /**
+     * Generate a fallback selection set when primary generation fails
+     * Uses progressive fallback strategies: comprehensive → selective → minimal
+     * Enhanced with comprehensive error handling and logging
+     */
+    generateFallbackSelectionSet(fieldName) {
+        try {
+            if (!fieldName) {
+                const error = this.errorHandler.logSelectionSetError(SelectionSetErrorType.INVALID_CONFIGURATION, 'Field name is empty or undefined for fallback generation', undefined, undefined, { fieldName });
+                return this.generateMinimalFallbackSelectionSet();
+            }
+            console.warn(`SelectionSetGenerator: Using fallback selection set for field "${fieldName}"`);
+            // Try progressive fallback strategies
+            try {
+                // Strategy 1: Comprehensive fallback (if schema is available)
+                if (this.schemaIntrospector.isSchemaAvailable()) {
+                    const result = this.generateComprehensiveFallbackSelectionSet(fieldName);
+                    console.log(`SelectionSetGenerator: Comprehensive fallback successful for field "${fieldName}"`);
+                    return result;
+                }
+                // Strategy 2: Selective fallback (configuration-based)
+                const result = this.generateSelectiveFallbackSelectionSet(fieldName);
+                console.log(`SelectionSetGenerator: Selective fallback successful for field "${fieldName}"`);
+                return result;
+            }
+            catch (error) {
+                const selectionSetError = this.errorHandler.logSelectionSetError(SelectionSetErrorType.GRAPHQL_ERROR, `Error in fallback generation, using minimal fallback: ${error instanceof Error ? error.message : String(error)}`, undefined, undefined, {
+                    fieldName,
+                    originalError: {
+                        message: error instanceof Error ? error.message : String(error),
+                        stack: error instanceof Error ? error.stack : undefined
+                    },
+                    schemaAvailable: this.schemaIntrospector.isSchemaAvailable()
+                });
+                // Strategy 3: Minimal fallback (last resort)
+                return this.generateMinimalFallbackSelectionSet(fieldName);
+            }
+        }
+        catch (error) {
+            // Absolute last resort - return basic selection set
+            const selectionSetError = this.errorHandler.logSelectionSetError(SelectionSetErrorType.GRAPHQL_ERROR, `Critical error in fallback generation: ${error instanceof Error ? error.message : String(error)}`, undefined, undefined, {
+                fieldName,
+                criticalError: {
+                    message: error instanceof Error ? error.message : String(error),
+                    stack: error instanceof Error ? error.stack : undefined
+                }
+            });
+            console.error('SelectionSetGenerator: Critical error in fallback generation, returning absolute minimal fallback');
+            return ['id'];
+        }
+    }
+    /**
+     * Generate comprehensive fallback selection set using schema data
+     * This is the first fallback strategy when schema is available
+     */
+    generateComprehensiveFallbackSelectionSet(fieldName) {
+        console.log(`SelectionSetGenerator: Using comprehensive fallback strategy for field "${fieldName}"`);
+        const selectionSet = ['id'];
+        try {
+            // Use schema introspector to get safe field selectors
+            const safeSelectors = this.schemaIntrospector.getSafeFieldSelectors('', fieldName);
+            // Add all safe selectors
+            for (const selector of safeSelectors) {
+                if (!selectionSet.includes(selector)) {
+                    selectionSet.push(selector);
+                }
+            }
+            // Apply display optimization for fallback
+            const mockConfig = {
+                relationshipModelName: '',
+                baseModelName: '',
+                fieldName,
+                associatedWith: ''
+            };
+            const optimizedSet = this.applyDisplayOptimization(selectionSet, mockConfig);
+            // Apply complexity limits to prevent overly expensive queries
+            return this.applyComplexityLimits(optimizedSet);
+        }
+        catch (error) {
+            console.warn('SelectionSetGenerator: Comprehensive fallback failed, falling back to selective:', error);
+            return this.generateSelectiveFallbackSelectionSet(fieldName);
+        }
+    }
+    /**
+     * Generate selective fallback selection set using common field patterns
+     * This is the second fallback strategy when schema is unavailable
+     */
+    generateSelectiveFallbackSelectionSet(fieldName) {
+        console.log(`SelectionSetGenerator: Using selective fallback strategy for field "${fieldName}"`);
+        const selectionSet = ['id'];
+        // Add the relationship field with id (always safe)
+        selectionSet.push(`${fieldName}.id`);
+        // Add common display fields that are likely to exist
+        const commonDisplayFields = ['name', 'title', 'label', 'displayName'];
+        for (const field of commonDisplayFields) {
+            selectionSet.push(`${fieldName}.${field}`);
+        }
+        // Add some additional fields that might be useful for display
+        const additionalFields = ['description', 'status', 'type'];
+        for (const field of additionalFields) {
+            selectionSet.push(`${fieldName}.${field}`);
+        }
+        return selectionSet;
+    }
+    /**
+     * Generate minimal fallback selection set for critical error cases
+     * This is the last resort fallback strategy
+     */
+    generateMinimalFallbackSelectionSet(fieldName) {
+        console.log(`SelectionSetGenerator: Using minimal fallback strategy${fieldName ? ` for field "${fieldName}"` : ''}`);
+        const selectionSet = ['id'];
+        if (fieldName) {
+            // Include only the most basic relationship data
+            selectionSet.push(`${fieldName}.id`);
+            // Add one common field that's most likely to exist
+            selectionSet.push(`${fieldName}.name`);
+        }
+        return selectionSet;
+    }
+    /**
+     * Generate fallback selection set with retry logic
+     * Attempts multiple fallback strategies and validates each one
+     * Enhanced with comprehensive error handling and recovery tracking
+     */
+    generateFallbackSelectionSetWithRetry(fieldName, previousErrors = []) {
+        try {
+            if (!fieldName) {
+                const error = this.errorHandler.logSelectionSetError(SelectionSetErrorType.INVALID_CONFIGURATION, 'Field name is empty for fallback retry generation', undefined, undefined, { previousErrors });
+                return ['id'];
+            }
+            console.log(`SelectionSetGenerator: Generating fallback with retry for field "${fieldName}", previous errors: ${previousErrors.length}`);
+            const strategies = [
+                () => this.generateComprehensiveFallbackSelectionSet(fieldName),
+                () => this.generateSelectiveFallbackSelectionSet(fieldName),
+                () => this.generateMinimalFallbackSelectionSet(fieldName)
+            ];
+            // Skip strategies that have already failed
+            const availableStrategies = strategies.slice(previousErrors.length);
+            for (let i = 0; i < availableStrategies.length; i++) {
+                try {
+                    const strategy = availableStrategies[i];
+                    const selectionSet = strategy();
+                    // Validate the selection set
+                    if (this.validateSelectionSet(selectionSet)) {
+                        const strategyName = ['comprehensive', 'selective', 'minimal'][previousErrors.length + i];
+                        console.log(`SelectionSetGenerator: Successfully generated ${strategyName} fallback selection set`);
+                        // Log successful recovery if this was after previous failures
+                        if (previousErrors.length > 0) {
+                            this.errorHandler.logSuccessfulRecovery(this.errorHandler.logSelectionSetError(SelectionSetErrorType.GRAPHQL_ERROR, `Previous errors: ${previousErrors.join(', ')}`, undefined, undefined, { fieldName, previousErrors }), strategyName, selectionSet);
+                        }
+                        return selectionSet;
+                    }
+                    else {
+                        const strategyName = ['comprehensive', 'selective', 'minimal'][previousErrors.length + i];
+                        const validationError = `Generated selection set failed validation for ${strategyName} strategy`;
+                        console.warn(`SelectionSetGenerator: ${validationError}`);
+                        previousErrors.push(validationError);
+                    }
+                }
+                catch (error) {
+                    const strategyName = ['comprehensive', 'selective', 'minimal'][previousErrors.length + i];
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    this.errorHandler.logSelectionSetError(SelectionSetErrorType.GRAPHQL_ERROR, `${strategyName} fallback strategy failed: ${errorMessage}`, undefined, undefined, {
+                        fieldName,
+                        strategyName,
+                        strategyIndex: previousErrors.length + i,
+                        originalError: {
+                            message: errorMessage,
+                            stack: error instanceof Error ? error.stack : undefined
+                        }
+                    });
+                    console.warn(`SelectionSetGenerator: ${strategyName} fallback strategy failed:`, error);
+                    previousErrors.push(errorMessage);
+                }
+            }
+            // If all strategies fail, log the complete failure and return absolute minimal fallback
+            this.errorHandler.logFailedRecovery(this.errorHandler.logSelectionSetError(SelectionSetErrorType.GRAPHQL_ERROR, 'All fallback strategies failed', undefined, undefined, { fieldName, previousErrors }), ['comprehensive', 'selective', 'minimal'], new Error('All fallback strategies exhausted'));
+            console.error('SelectionSetGenerator: All fallback strategies failed, using absolute minimal fallback');
+            return ['id'];
+        }
+        catch (error) {
+            // Critical error in retry logic itself
+            this.errorHandler.logSelectionSetError(SelectionSetErrorType.GRAPHQL_ERROR, `Critical error in fallback retry logic: ${error instanceof Error ? error.message : String(error)}`, undefined, undefined, {
+                fieldName,
+                previousErrors,
+                criticalError: {
+                    message: error instanceof Error ? error.message : String(error),
+                    stack: error instanceof Error ? error.stack : undefined
+                }
+            });
+            console.error('SelectionSetGenerator: Critical error in fallback retry logic:', error);
+            return ['id'];
+        }
+    }
+    /**
+     * Handle generation errors by attempting fallback with comprehensive logging
+     */
+    handleGenerationError(error, fieldName) {
+        try {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.warn(`SelectionSetGenerator: Handling generation error for field "${fieldName}":`, errorMessage);
+            // Attempt fallback with retry logic
+            const fallbackResult = this.generateFallbackSelectionSetWithRetry(fieldName, [errorMessage]);
+            // Log the fallback attempt
+            console.log(`SelectionSetGenerator: Fallback generated for field "${fieldName}":`, fallbackResult);
+            return fallbackResult;
+        }
+        catch (fallbackError) {
+            // Even fallback failed - return absolute minimal
+            this.errorHandler.logSelectionSetError(SelectionSetErrorType.GRAPHQL_ERROR, `Both primary generation and fallback failed: ${fallbackError instanceof Error ? fallbackError.message : String(fallbackError)}`, undefined, undefined, {
+                fieldName,
+                originalError: error,
+                fallbackError: {
+                    message: fallbackError instanceof Error ? fallbackError.message : String(fallbackError),
+                    stack: fallbackError instanceof Error ? fallbackError.stack : undefined
+                }
+            });
+            console.error('SelectionSetGenerator: Both primary generation and fallback failed, returning minimal selection set');
+            return ['id'];
+        }
+    }
+    /**
+     * Validate a selection set for basic correctness
+     */
+    validateSelectionSet(selectionSet) {
+        if (!Array.isArray(selectionSet) || selectionSet.length === 0) {
+            return false;
+        }
+        // Must include 'id' field
+        if (!selectionSet.includes('id')) {
+            return false;
+        }
+        // Check for obviously invalid selectors
+        for (const selector of selectionSet) {
+            if (typeof selector !== 'string' || selector.trim() === '') {
+                return false;
+            }
+            // Check for dangerous patterns
+            if (selector.includes('..') || selector.includes('*') || selector.length > 100) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Clear the internal cache of generated selection sets
+     */
+    clearCache() {
+        this.selectionSetCache.clear();
+        console.log('SelectionSetGenerator: Cache cleared');
+    }
+    /**
+     * Generate selection set from configuration analysis result
+     */
+    generateSelectionSetFromAnalysis(config, analysisResult) {
+        const selectionSet = [];
+        // Always include the base record ID
+        selectionSet.push('id');
+        if (this.schemaIntrospector.isSchemaAvailable()) {
+            // Use schema-aware generation
+            return this.generateSchemaAwareSelectionSet(config, analysisResult);
+        }
+        else {
+            // Use configuration-based generation
+            return this.generateConfigurationBasedSelectionSet(config, analysisResult);
+        }
+    }
+    /**
+     * Generate selection set using schema introspection data
+     */
+    generateSchemaAwareSelectionSet(config, analysisResult) {
+        const selectionSet = ['id'];
+        // Get safe field selectors from schema introspector
+        const safeSelectors = this.schemaIntrospector.getSafeFieldSelectors(analysisResult.targetModelName, config.fieldName);
+        // Add schema-validated selectors
+        for (const selector of safeSelectors) {
+            if (!selectionSet.includes(selector)) {
+                selectionSet.push(selector);
+            }
+        }
+        // Apply display optimization if enabled
+        const optimizedSet = this.applyDisplayOptimization(selectionSet, config);
+        // Apply complexity limits
+        return this.applyComplexityLimits(optimizedSet);
+    }
+    /**
+     * Generate selection set using configuration analysis only
+     */
+    generateConfigurationBasedSelectionSet(config, analysisResult) {
+        const selectionSet = ['id'];
+        console.log('SelectionSetGenerator: Generating configuration-based selection set:', {
+            config: {
+                relationshipModelName: config.relationshipModelName,
+                fieldName: config.fieldName,
+                baseModelName: config.baseModelName,
+                associatedWith: config.associatedWith
+            },
+            analysisResult: {
+                targetModelName: analysisResult.targetModelName,
+                fieldSelectorsCount: analysisResult.fieldSelectors?.length || 0,
+                fieldSelectors: analysisResult.fieldSelectors
+            }
+        });
+        // Use the field selectors from configuration analysis
+        for (const selector of analysisResult.fieldSelectors) {
+            if (!selectionSet.includes(selector)) {
+                selectionSet.push(selector);
+            }
+        }
+        console.log('SelectionSetGenerator: Configuration-based selection set before optimization:', selectionSet);
+        // Apply display optimization if enabled
+        const optimizedSet = this.applyDisplayOptimization(selectionSet, config);
+        console.log('SelectionSetGenerator: Selection set after display optimization:', optimizedSet);
+        // Apply complexity limits
+        const finalSet = this.applyComplexityLimits(optimizedSet);
+        console.log('SelectionSetGenerator: Final configuration-based selection set:', finalSet);
+        return finalSet;
+    }
+    /**
+     * Apply display optimization to prioritize display-relevant fields
+     */
+    applyDisplayOptimization(selectionSet, config) {
+        const displayConfig = this.DEFAULT_DISPLAY_CONFIG;
+        if (!displayConfig.enabled) {
+            return selectionSet;
+        }
+        // Analyze each field for display relevance
+        const fieldAnalyses = selectionSet.map(selector => this.analyzeFieldForDisplay(selector, config));
+        // Sort by priority (higher priority first)
+        fieldAnalyses.sort((a, b) => b.priority - a.priority);
+        // Build optimized selection set
+        const optimizedSet = [];
+        const essentialFields = [];
+        const displayFields = [];
+        const otherFields = [];
+        // Categorize fields
+        for (const analysis of fieldAnalyses) {
+            switch (analysis.classification) {
+                case FieldClassification.ESSENTIAL:
+                    essentialFields.push(analysis.selector);
+                    break;
+                case FieldClassification.DISPLAY:
+                    displayFields.push(analysis.selector);
+                    break;
+                default:
+                    otherFields.push(analysis.selector);
+                    break;
+            }
+        }
+        // Add essential fields first (always included)
+        optimizedSet.push(...essentialFields);
+        // Add display fields (prioritized)
+        optimizedSet.push(...displayFields);
+        // Add other fields up to the limit
+        const remainingSlots = Math.max(0, displayConfig.maxNonDisplayFields - (optimizedSet.length - essentialFields.length));
+        optimizedSet.push(...otherFields.slice(0, remainingSlots));
+        console.log(`SelectionSetGenerator: Display optimization reduced selection set from ${selectionSet.length} to ${optimizedSet.length} fields`);
+        return optimizedSet;
+    }
+    /**
+     * Analyze a field selector for display optimization
+     */
+    analyzeFieldForDisplay(selector, config) {
+        const displayConfig = this.DEFAULT_DISPLAY_CONFIG;
+        const analysis = {
+            selector,
+            classification: FieldClassification.UNKNOWN,
+            priority: 0,
+            cost: 1,
+            isDisplayRelevant: false
+        };
+        // Essential fields (always required)
+        if (displayConfig.excludeFromOptimization.some(field => selector.includes(field))) {
+            analysis.classification = FieldClassification.ESSENTIAL;
+            analysis.priority = 100;
+            analysis.isDisplayRelevant = true;
+            return analysis;
+        }
+        // Check if it's a common display field
+        const isDisplayField = displayConfig.commonDisplayFields.some(field => selector.endsWith(`.${field}`) || selector === field);
+        if (isDisplayField) {
+            analysis.classification = FieldClassification.DISPLAY;
+            analysis.priority = 80;
+            analysis.isDisplayRelevant = true;
+        }
+        else if (this.isRelationshipField(selector)) {
+            analysis.classification = FieldClassification.RELATIONSHIP;
+            analysis.priority = 60;
+            analysis.cost = 2; // Relationships are more expensive
+            analysis.isDisplayRelevant = this.isDisplayRelevantRelationship(selector);
+        }
+        else if (this.isMetadataField(selector)) {
+            analysis.classification = FieldClassification.METADATA;
+            analysis.priority = 40;
+            analysis.isDisplayRelevant = false;
+        }
+        else if (this.isSystemField(selector)) {
+            analysis.classification = FieldClassification.SYSTEM;
+            analysis.priority = 20;
+            analysis.isDisplayRelevant = false;
+        }
+        else {
+            analysis.classification = FieldClassification.UNKNOWN;
+            analysis.priority = 30;
+            analysis.isDisplayRelevant = false;
+        }
+        // Adjust priority based on field depth (deeper fields are less likely to be displayed)
+        const depth = (selector.match(/\./g) || []).length;
+        analysis.priority -= depth * 5;
+        analysis.cost += depth;
+        // Boost priority for fields that match the relationship field name
+        if (selector.includes(config.fieldName)) {
+            analysis.priority += 10;
+            analysis.isDisplayRelevant = true;
+        }
+        return analysis;
+    }
+    /**
+     * Check if a selector represents a relationship field
+     */
+    isRelationshipField(selector) {
+        // Relationship fields typically have dots (nested access) or end with common relationship suffixes
+        return selector.includes('.') ||
+            selector.endsWith('Id') ||
+            selector.endsWith('Ids') ||
+            selector.endsWith('Connection');
+    }
+    /**
+     * Check if a relationship field is likely to be displayed
+     */
+    isDisplayRelevantRelationship(selector) {
+        // Display-relevant relationships typically access display fields of related models
+        const displayFieldPatterns = ['name', 'title', 'label', 'displayName', 'description'];
+        return displayFieldPatterns.some(pattern => selector.includes(pattern));
+    }
+    /**
+     * Check if a selector represents a metadata field
+     */
+    isMetadataField(selector) {
+        const metadataPatterns = ['createdAt', 'updatedAt', 'version', 'owner', 'lastModified'];
+        return metadataPatterns.some(pattern => selector.includes(pattern));
+    }
+    /**
+     * Check if a selector represents a system field
+     */
+    isSystemField(selector) {
+        const systemPatterns = ['__typename', '_version', '_deleted', '_lastChangedAt'];
+        return systemPatterns.some(pattern => selector.includes(pattern));
+    }
+    /**
+     * Apply complexity limits to prevent overly expensive GraphQL queries
+     * Enhanced with comprehensive error handling and logging
+     */
+    applyComplexityLimits(selectionSet) {
+        try {
+            // First validate the selection set for complexity
+            const validationResult = this.validateSelectionSetComplexity(selectionSet);
+            if (validationResult.isValid) {
+                console.log('SelectionSetGenerator: Selection set passed complexity validation');
+                return selectionSet;
+            }
+            // Log validation issues
+            if (validationResult.errors.length > 0) {
+                this.errorHandler.logComplexityError(selectionSet, validationResult.errors);
+                console.warn('SelectionSetGenerator: Complexity validation errors:', validationResult.errors);
+            }
+            if (validationResult.warnings.length > 0) {
+                console.warn('SelectionSetGenerator: Complexity validation warnings:', validationResult.warnings);
+            }
+            // Apply fixes to make the selection set compliant
+            const fixedSet = this.fixComplexityIssues(selectionSet, validationResult);
+            // Validate the fixed set
+            const revalidationResult = this.validateSelectionSetComplexity(fixedSet);
+            if (!revalidationResult.isValid) {
+                this.errorHandler.logSelectionSetError(SelectionSetErrorType.COMPLEXITY_EXCEEDED, 'Selection set still exceeds complexity limits after fixes', undefined, fixedSet, {
+                    originalSelectionSet: selectionSet,
+                    validationResult,
+                    revalidationResult
+                });
+                // Return minimal fallback if fixes didn't work
+                console.warn('SelectionSetGenerator: Complexity fixes failed, returning minimal selection set');
+                return ['id'];
+            }
+            console.log(`SelectionSetGenerator: Applied complexity fixes, reduced from ${selectionSet.length} to ${fixedSet.length} fields`);
+            return fixedSet;
+        }
+        catch (error) {
+            this.errorHandler.logSelectionSetError(SelectionSetErrorType.COMPLEXITY_EXCEEDED, `Error applying complexity limits: ${error instanceof Error ? error.message : String(error)}`, undefined, selectionSet, {
+                originalError: {
+                    message: error instanceof Error ? error.message : String(error),
+                    stack: error instanceof Error ? error.stack : undefined
+                }
+            });
+            console.error('SelectionSetGenerator: Error applying complexity limits:', error);
+            // Return original set if complexity checking fails
+            return selectionSet;
+        }
+    }
+    /**
+     * Validate selection set complexity against configured limits
+     */
+    validateSelectionSetComplexity(selectionSet) {
+        const limits = this.DEFAULT_CONFIG.complexityLimits;
+        const result = {
+            isValid: true,
+            errors: [],
+            warnings: [],
+            complexityScore: 0,
+            circularReferences: []
+        };
+        // Track field paths for circular reference detection
+        const fieldPaths = new Set();
+        const pathComponents = new Map();
+        let wildcardCount = 0;
+        let maxDepth = 0;
+        for (const selector of selectionSet) {
+            // Check selector length
+            if (selector.length > limits.maxSelectorLength) {
+                result.errors.push(`Selector "${selector}" exceeds maximum length of ${limits.maxSelectorLength}`);
+                result.isValid = false;
+            }
+            // Check for wildcard selections
+            if (selector.includes('*')) {
+                wildcardCount++;
+                if (wildcardCount > limits.maxWildcardSelections) {
+                    result.errors.push(`Too many wildcard selections (${wildcardCount}), maximum allowed: ${limits.maxWildcardSelections}`);
+                    result.isValid = false;
+                }
+            }
+            // Calculate nesting depth
+            const depth = (selector.match(/\./g) || []).length;
+            maxDepth = Math.max(maxDepth, depth);
+            if (depth > limits.maxNestingDepth) {
+                result.errors.push(`Selector "${selector}" exceeds maximum nesting depth of ${limits.maxNestingDepth}`);
+                result.isValid = false;
+            }
+            // Track field paths for circular reference detection
+            if (limits.preventCircularReferences && depth > 0) {
+                const components = selector.split('.');
+                pathComponents.set(selector, components);
+                // Check for potential circular references
+                const circularRef = this.detectCircularReference(components, pathComponents);
+                if (circularRef) {
+                    result.circularReferences.push(circularRef);
+                    result.warnings.push(`Potential circular reference detected: ${circularRef}`);
+                }
+            }
+            fieldPaths.add(selector);
+        }
+        // Check field count limit
+        if (selectionSet.length > limits.maxFieldCount) {
+            result.errors.push(`Selection set has ${selectionSet.length} fields, maximum allowed: ${limits.maxFieldCount}`);
+            result.isValid = false;
+        }
+        // Calculate complexity score
+        result.complexityScore = this.calculateComplexityScore(selectionSet, maxDepth, wildcardCount);
+        // Add warnings for high complexity
+        if (result.complexityScore > 50) {
+            result.warnings.push(`High complexity score: ${result.complexityScore}`);
+        }
+        return result;
+    }
+    /**
+     * Detect circular references in field paths
+     */
+    detectCircularReference(components, allPaths) {
+        // Simple circular reference detection: check if any component appears multiple times in the path
+        const componentCounts = new Map();
+        for (const component of components) {
+            const count = componentCounts.get(component) || 0;
+            componentCounts.set(component, count + 1);
+            if (count > 0) {
+                return components.join('.');
+            }
+        }
+        return null;
+    }
+    /**
+     * Calculate complexity score for a selection set
+     */
+    calculateComplexityScore(selectionSet, maxDepth, wildcardCount) {
+        let score = 0;
+        // Base score from field count
+        score += selectionSet.length;
+        // Penalty for depth
+        score += maxDepth * 5;
+        // Heavy penalty for wildcards
+        score += wildcardCount * 10;
+        // Penalty for complex selectors
+        for (const selector of selectionSet) {
+            if (selector.includes('*')) {
+                score += 5;
+            }
+            if (selector.split('.').length > 2) {
+                score += 3;
+            }
+        }
+        return score;
+    }
+    /**
+     * Fix complexity issues in a selection set
+     */
+    fixComplexityIssues(selectionSet, validationResult) {
+        const limits = this.DEFAULT_CONFIG.complexityLimits;
+        let fixedSet = [...selectionSet];
+        // Remove selectors that are too long
+        fixedSet = fixedSet.filter(selector => {
+            if (selector.length > limits.maxSelectorLength) {
+                console.warn(`SelectionSetGenerator: Removing selector "${selector}" due to excessive length`);
+                return false;
+            }
+            return true;
+        });
+        // Remove selectors that are too deeply nested
+        fixedSet = fixedSet.filter(selector => {
+            const depth = (selector.match(/\./g) || []).length;
+            if (depth > limits.maxNestingDepth) {
+                console.warn(`SelectionSetGenerator: Removing selector "${selector}" due to excessive nesting depth`);
+                return false;
+            }
+            return true;
+        });
+        // Limit wildcard selections
+        let wildcardCount = 0;
+        fixedSet = fixedSet.filter(selector => {
+            if (selector.includes('*')) {
+                wildcardCount++;
+                if (wildcardCount > limits.maxWildcardSelections) {
+                    console.warn(`SelectionSetGenerator: Removing wildcard selector "${selector}" due to limit`);
+                    return false;
+                }
+            }
+            return true;
+        });
+        // Remove circular references
+        if (limits.preventCircularReferences && validationResult.circularReferences.length > 0) {
+            const circularSelectors = new Set(validationResult.circularReferences);
+            fixedSet = fixedSet.filter(selector => {
+                if (circularSelectors.has(selector)) {
+                    console.warn(`SelectionSetGenerator: Removing selector "${selector}" due to circular reference`);
+                    return false;
+                }
+                return true;
+            });
+        }
+        // Truncate to field count limit
+        if (fixedSet.length > limits.maxFieldCount) {
+            console.warn(`SelectionSetGenerator: Truncating selection set from ${fixedSet.length} to ${limits.maxFieldCount} fields`);
+            fixedSet = fixedSet.slice(0, limits.maxFieldCount);
+        }
+        // Ensure required fields are still present
+        for (const requiredField of this.DEFAULT_CONFIG.requiredFields) {
+            if (!fixedSet.includes(requiredField)) {
+                fixedSet.unshift(requiredField);
+            }
+        }
+        return fixedSet;
+    }
+    /**
+     * Generate a cache key for a relationship configuration
+     */
+    generateCacheKey(config) {
+        const key = {
+            relationshipModel: config.relationshipModelName,
+            fieldName: config.fieldName,
+            targetModel: this.configurationAnalyzer.extractTargetModelName(config),
+            schemaVersion: this.getSchemaVersion()
+        };
+        return JSON.stringify(key);
+    }
+    /**
+     * Get cached selection set if available
+     */
+    getCachedSelectionSet(cacheKey) {
+        const cached = this.selectionSetCache.get(cacheKey);
+        if (cached) {
+            // Update access count
+            cached.accessCount++;
+            return cached;
+        }
+        return null;
+    }
+    /**
+     * Cache a generated selection set
+     */
+    cacheSelectionSet(cacheKey, selectionSet) {
+        const cached = {
+            key: JSON.parse(cacheKey),
+            selectionSet: [...selectionSet],
+            createdAt: new Date(),
+            accessCount: 1
+        };
+        this.selectionSetCache.set(cacheKey, cached);
+        // Implement simple cache size limit
+        if (this.selectionSetCache.size > 100) {
+            this.evictOldestCacheEntries();
+        }
+    }
+    /**
+     * Evict oldest cache entries when cache gets too large
+     */
+    evictOldestCacheEntries() {
+        const entries = Array.from(this.selectionSetCache.entries());
+        entries.sort((a, b) => a[1].createdAt.getTime() - b[1].createdAt.getTime());
+        // Remove oldest 20% of entries
+        const toRemove = Math.floor(entries.length * 0.2);
+        for (let i = 0; i < toRemove; i++) {
+            this.selectionSetCache.delete(entries[i][0]);
+        }
+        console.log(`SelectionSetGenerator: Evicted ${toRemove} old cache entries`);
+    }
+    /**
+     * Get schema version for cache invalidation
+     */
+    getSchemaVersion() {
+        // In a real implementation, this could be based on schema hash or version
+        // For now, we'll use schema availability as a simple version indicator
+        return this.schemaIntrospector.isSchemaAvailable() ? 'schema-available' : 'schema-unavailable';
+    }
+    /**
+     * Get cache statistics for debugging
+     */
+    getCacheStats() {
+        const entries = Array.from(this.selectionSetCache.values());
+        const totalAccesses = entries.reduce((sum, entry) => sum + entry.accessCount, 0);
+        return {
+            size: this.selectionSetCache.size,
+            totalAccesses,
+            entries: entries.map(entry => ({
+                key: entry.key,
+                selectionSet: [...entry.selectionSet],
+                createdAt: entry.createdAt,
+                accessCount: entry.accessCount
+            }))
+        };
+    }
+    /**
+     * Get optimization statistics for debugging
+     */
+    getOptimizationStats() {
+        return {
+            displayOptimizationEnabled: this.DEFAULT_DISPLAY_CONFIG.enabled,
+            complexityLimits: { ...this.DEFAULT_CONFIG.complexityLimits },
+            displayConfig: { ...this.DEFAULT_DISPLAY_CONFIG }
+        };
+    }
+    /**
+     * Analyze a selection set for optimization opportunities
+     */
+    analyzeSelectionSetOptimization(selectionSet) {
+        const mockConfig = {
+            relationshipModelName: '',
+            baseModelName: '',
+            fieldName: 'mock',
+            associatedWith: ''
+        };
+        const analyses = selectionSet.map(selector => this.analyzeFieldForDisplay(selector, mockConfig));
+        const displayRelevantCount = analyses.filter(a => a.isDisplayRelevant).length;
+        const complexityScore = this.calculateComplexityScore(selectionSet, Math.max(...selectionSet.map(s => (s.match(/\./g) || []).length)), selectionSet.filter(s => s.includes('*')).length);
+        const opportunities = [];
+        // Identify optimization opportunities
+        if (displayRelevantCount < selectionSet.length * 0.5) {
+            opportunities.push('Many non-display fields could be removed');
+        }
+        if (complexityScore > 30) {
+            opportunities.push('High complexity score suggests simplification needed');
+        }
+        const deepFields = selectionSet.filter(s => (s.match(/\./g) || []).length > 2);
+        if (deepFields.length > 0) {
+            opportunities.push(`${deepFields.length} deeply nested fields could be simplified`);
+        }
+        const wildcardFields = selectionSet.filter(s => s.includes('*'));
+        if (wildcardFields.length > 1) {
+            opportunities.push(`${wildcardFields.length} wildcard selections could be made more specific`);
+        }
+        return {
+            totalFields: selectionSet.length,
+            displayRelevantFields: displayRelevantCount,
+            complexityScore,
+            optimizationOpportunities: opportunities
+        };
+    }
+    /**
+     * Initialize the service with schema data
+     */
+    initializeWithSchema(amplifyOutputs) {
+        this.schemaIntrospector.initializeSchema(amplifyOutputs);
+        this.clearCache(); // Clear cache when schema changes
+        console.log('SelectionSetGenerator: Initialized with schema data');
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: SelectionSetGeneratorService, deps: [{ token: ConfigurationAnalyzerService }, { token: SchemaIntrospectorService }, { token: ErrorHandlerService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: SelectionSetGeneratorService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: SelectionSetGeneratorService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: ConfigurationAnalyzerService }, { type: SchemaIntrospectorService }, { type: ErrorHandlerService }] });
+
 class AmplifyAngularCore {
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: AmplifyAngularCore, deps: [], target: i0.ɵɵFactoryTarget.Component });
     static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "20.3.15", type: AmplifyAngularCore, isStandalone: true, selector: "snteam-amplify-angular-core", ngImport: i0, template: `
@@ -44,7 +2101,7 @@ class AmplifyAngularCore {
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: AmplifyAngularCore, decorators: [{
             type: Component,
-            args: [{ selector: 'snteam-amplify-angular-core', imports: [], template: `
+            args: [{ selector: 'snteam-amplify-angular-core', standalone: true, imports: [], template: `
     <p>
       amplify-angular-core works!
     </p>
@@ -236,8 +2293,12 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImpo
         }] });
 
 class AmplifyModelService {
+    selectionSetGenerator;
+    errorHandler;
     client;
-    constructor() {
+    constructor(selectionSetGenerator, errorHandler) {
+        this.selectionSetGenerator = selectionSetGenerator;
+        this.errorHandler = errorHandler;
         // Client will be initialized when Amplify is configured by the consuming application
     }
     /**
@@ -424,14 +2485,65 @@ class AmplifyModelService {
             return condition;
         }
     }
+    /**
+     * Generate dynamic selection set for relationship queries
+     * Replaces hardcoded selection set logic with dynamic generation
+     * Enhanced with comprehensive error handling and logging
+     * @param config Relationship configuration object
+     * @param baseId Base record ID (for compatibility, not used in generation)
+     * @returns Array of GraphQL field selectors
+     */
     getAmplifySelectionSet(config, baseId) {
-        switch (config.fieldName) {
-            case 'service':
-                return ['id', 'service.title', 'service.price', 'service.id'];
-            case 'customer':
-                return ['id', 'customer.*'];
-            default:
-                return [];
+        try {
+            if (!config) {
+                const error = this.errorHandler.logSelectionSetError(SelectionSetErrorType.INVALID_CONFIGURATION, 'Configuration is null or undefined', config, undefined, {
+                    method: 'getAmplifySelectionSet',
+                    baseId,
+                    clientAvailable: !!this.client
+                });
+                // Return minimal fallback
+                return ['id'];
+            }
+            console.log('AmplifyModelService: Generating dynamic selection set for config:', {
+                relationshipModel: config.relationshipModelName,
+                fieldName: config.fieldName,
+                baseId
+            });
+            // Use the SelectionSetGenerator to create dynamic selection sets
+            const selectionSet = this.selectionSetGenerator.generateSelectionSet(config);
+            if (!selectionSet || selectionSet.length === 0) {
+                const error = this.errorHandler.logSelectionSetError(SelectionSetErrorType.GRAPHQL_ERROR, 'Selection set generator returned empty or null result', config, selectionSet, {
+                    method: 'getAmplifySelectionSet',
+                    baseId,
+                    generatorAvailable: !!this.selectionSetGenerator
+                });
+                // Return minimal fallback
+                return ['id'];
+            }
+            console.log('AmplifyModelService: Generated selection set:', {
+                config: config.fieldName,
+                selectionSetLength: selectionSet.length,
+                selectionSet
+            });
+            return selectionSet;
+        }
+        catch (error) {
+            const selectionSetError = this.errorHandler.logSelectionSetError(SelectionSetErrorType.GRAPHQL_ERROR, `Unexpected error generating selection set: ${error instanceof Error ? error.message : String(error)}`, config, undefined, {
+                method: 'getAmplifySelectionSet',
+                baseId,
+                originalError: {
+                    message: error instanceof Error ? error.message : String(error),
+                    stack: error instanceof Error ? error.stack : undefined,
+                    type: typeof error
+                },
+                context: {
+                    clientAvailable: !!this.client,
+                    selectionSetGeneratorAvailable: !!this.selectionSetGenerator
+                }
+            });
+            console.error('AmplifyModelService: Error generating selection set, using fallback:', error);
+            // Use fallback selection set generation with retry logic
+            return this.selectionSetGenerator.generateFallbackSelectionSetWithRetry(config?.fieldName || '', [error instanceof Error ? error.message : String(error)]);
         }
     }
     setRelatedSub(config, baseId) {
@@ -445,32 +2557,389 @@ class AmplifyModelService {
             return this.client.models[modelName].onCreate({ filter: filter });
         }
         else {
-            console.error(`Relationship model ${modelName} not found in client`);
-            return null;
+            console.error(`Relationship model ${modelName} not found in client`);
+            return null;
+        }
+    }
+    /**
+     * Get related items with enhanced error handling and retry logic
+     * @param config Relationship configuration object
+     * @param baseId Base record ID to filter relationships
+     * @returns Observable of related items with retry logic on GraphQL errors
+     */
+    getRelatedItems(config, baseId) {
+        if (!this.client) {
+            console.error('AmplifyModelService: Client not initialized. Call initializeClient() first.');
+            return null;
+        }
+        const filter = this.getRelationshipFilter(config, baseId);
+        const modelName = config.relationshipModelName;
+        if (!this.client.models[modelName]) {
+            console.error(`AmplifyModelService: Relationship model ${modelName} not found in client`);
+            return null;
+        }
+        // Attempt to get related items with progressive retry logic
+        return this.getRelatedItemsWithRetry(config, baseId, filter, modelName);
+    }
+    /**
+     * Get related items with progressive retry logic for GraphQL errors
+     * Implements progressive fallback: original → comprehensive → selective → minimal
+     */
+    getRelatedItemsWithRetry(config, baseId, filter, modelName, retryAttempt = 0, previousErrors = []) {
+        const maxRetries = 3;
+        try {
+            // Generate selection set based on retry attempt
+            let selectionSet;
+            if (retryAttempt === 0) {
+                // First attempt: Use dynamic generation
+                selectionSet = this.getAmplifySelectionSet(config, baseId);
+            }
+            else {
+                // Subsequent attempts: Use progressive fallback
+                console.log(`AmplifyModelService: Retry attempt ${retryAttempt} for ${modelName}, using fallback selection set`);
+                selectionSet = this.selectionSetGenerator.generateFallbackSelectionSetWithRetry(config.fieldName, previousErrors);
+            }
+            // Log the attempt
+            this.logQueryAttempt(config, selectionSet, retryAttempt, previousErrors);
+            // Prepare query options
+            const queryOptions = { filter: filter };
+            // Only include selectionSet if it's not empty to avoid GraphQL syntax errors
+            if (selectionSet && selectionSet.length > 0) {
+                queryOptions.selectionSet = [...selectionSet];
+            }
+            // Execute the query
+            const queryObservable = this.client.models[modelName].observeQuery(queryOptions);
+            // Wrap the observable to handle GraphQL errors with retry logic
+            return new Observable(subscriber => {
+                const subscription = queryObservable.subscribe({
+                    next: (result) => {
+                        // Log successful query
+                        this.logQuerySuccess(config, selectionSet, retryAttempt, result);
+                        // Validate that relationship field data is populated
+                        if (this.validateRelationshipFieldPopulation(result, config)) {
+                            subscriber.next(result);
+                        }
+                        else {
+                            // Relationship field not populated, try retry if possible
+                            const error = new Error(`Relationship field '${config.fieldName}' not populated in query results`);
+                            this.handleQueryError(error, config, baseId, filter, modelName, retryAttempt, previousErrors, subscriber);
+                        }
+                    },
+                    error: (error) => {
+                        this.handleQueryError(error, config, baseId, filter, modelName, retryAttempt, previousErrors, subscriber);
+                    },
+                    complete: () => {
+                        subscriber.complete();
+                    }
+                });
+                // Return cleanup function
+                return () => subscription.unsubscribe();
+            });
+        }
+        catch (error) {
+            console.error(`AmplifyModelService: Error in retry attempt ${retryAttempt}:`, error);
+            // If we've exhausted retries, return null
+            if (retryAttempt >= maxRetries) {
+                this.logFinalFailure(config, previousErrors, error);
+                return null;
+            }
+            // Try next retry level
+            const newErrors = [...previousErrors, error instanceof Error ? error.message : String(error)];
+            return this.getRelatedItemsWithRetry(config, baseId, filter, modelName, retryAttempt + 1, newErrors);
+        }
+    }
+    /**
+     * Handle GraphQL query errors with retry logic
+     * Enhanced with comprehensive error logging and context
+     */
+    handleQueryError(error, config, baseId, filter, modelName, retryAttempt, previousErrors, subscriber) {
+        const maxRetries = 3;
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        // Log comprehensive error details using ErrorHandlerService
+        const selectionSetError = this.errorHandler.logGraphQLError(error, config, [], // Selection set will be logged separately in retry attempts
+        retryAttempt, previousErrors);
+        console.error(`AmplifyModelService: GraphQL query error on attempt ${retryAttempt + 1}:`, error);
+        // Check if we should retry
+        if (retryAttempt < maxRetries && this.shouldRetryOnError(error)) {
+            console.log(`AmplifyModelService: Retrying with simpler selection set (attempt ${retryAttempt + 1}/${maxRetries})`);
+            // Add current error to the list
+            const newErrors = [...previousErrors, errorMessage];
+            // Attempt retry with next fallback level
+            const retryObservable = this.getRelatedItemsWithRetry(config, baseId, filter, modelName, retryAttempt + 1, newErrors);
+            if (retryObservable) {
+                // Subscribe to retry attempt
+                const retrySubscription = retryObservable.subscribe({
+                    next: (result) => {
+                        // Log successful recovery
+                        this.errorHandler.logSuccessfulRecovery(selectionSetError, `retry_attempt_${retryAttempt + 1}`, [] // Selection set would be determined in retry
+                        );
+                        subscriber.next(result);
+                    },
+                    error: (retryError) => subscriber.error(retryError),
+                    complete: () => subscriber.complete()
+                });
+                // Handle cleanup
+                subscriber.add(() => retrySubscription.unsubscribe());
+            }
+            else {
+                // No more retries possible
+                this.errorHandler.logFailedRecovery(selectionSetError, newErrors, new Error('Retry observable creation failed'));
+                subscriber.error(error);
+            }
+        }
+        else {
+            // No more retries or error is not retryable
+            const finalErrors = [...previousErrors, errorMessage];
+            this.errorHandler.logFailedRecovery(selectionSetError, finalErrors, error);
+            console.error('AmplifyModelService: All retry attempts exhausted or error not retryable');
+            subscriber.error(error);
         }
     }
     /**
-     * @param config {object} - see dynamic-relationship-builder.component getDetailsForManyToMany() for example of building config
+     * Determine if an error should trigger a retry
+     * Enhanced with comprehensive error pattern matching
      */
-    getRelatedItems(config, baseId) {
-        if (!this.client) {
-            console.error('AmplifyModelService: Client not initialized. Call initializeClient() first.');
-            return null;
+    shouldRetryOnError(error) {
+        try {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const errorString = errorMessage.toLowerCase();
+            // Retry on GraphQL field errors, selection set errors, but not on auth errors
+            const retryableErrors = [
+                'field',
+                'selection',
+                'cannot query',
+                'unknown field',
+                'syntax error',
+                'invalid selection set',
+                'validation error',
+                'parse error'
+            ];
+            const nonRetryableErrors = [
+                'unauthorized',
+                'forbidden',
+                'access denied',
+                'authentication',
+                'permission',
+                'not authorized',
+                'invalid credentials'
+            ];
+            // Don't retry on auth errors
+            if (nonRetryableErrors.some(pattern => errorString.includes(pattern))) {
+                console.log(`AmplifyModelService: Not retrying due to auth error: ${errorMessage}`);
+                return false;
+            }
+            // Retry on field/selection errors
+            const shouldRetry = retryableErrors.some(pattern => errorString.includes(pattern));
+            console.log(`AmplifyModelService: Error retry decision: ${shouldRetry} for error: ${errorMessage}`);
+            return shouldRetry;
+        }
+        catch (retryDecisionError) {
+            this.errorHandler.logSelectionSetError(SelectionSetErrorType.GRAPHQL_ERROR, `Error determining retry eligibility: ${retryDecisionError instanceof Error ? retryDecisionError.message : String(retryDecisionError)}`, undefined, undefined, {
+                method: 'shouldRetryOnError',
+                originalError: error,
+                retryDecisionError: {
+                    message: retryDecisionError instanceof Error ? retryDecisionError.message : String(retryDecisionError),
+                    stack: retryDecisionError instanceof Error ? retryDecisionError.stack : undefined
+                }
+            });
+            // Default to not retrying if we can't determine
+            return false;
         }
-        let filter = this.getRelationshipFilter(config, baseId);
-        let selectionSet = this.getAmplifySelectionSet(config, baseId);
-        const modelName = config.relationshipModelName;
-        if (this.client.models[modelName]) {
-            // Only include selectionSet if it's not empty to avoid GraphQL syntax errors
-            const queryOptions = { filter: filter };
-            if (selectionSet && selectionSet.length > 0) {
-                queryOptions.selectionSet = [...selectionSet];
+    }
+    /**
+     * Validate that relationship field data is populated in query results
+     * Enhanced with comprehensive error logging and flexible validation
+     */
+    validateRelationshipFieldPopulation(result, config) {
+        try {
+            if (!result || !result.data) {
+                this.errorHandler.logSelectionSetError(SelectionSetErrorType.GRAPHQL_ERROR, 'Query result is missing or has no data property', config, undefined, {
+                    method: 'validateRelationshipFieldPopulation',
+                    hasResult: !!result,
+                    hasData: !!(result?.data)
+                });
+                return false;
+            }
+            // Check if any records have the relationship field populated
+            const records = Array.isArray(result.data) ? result.data : [result.data];
+            let populatedCount = 0;
+            let partiallyPopulatedCount = 0;
+            for (const record of records) {
+                if (!record)
+                    continue;
+                const relationshipData = record[config.fieldName];
+                // Check for fully populated relationship (object with data)
+                if (relationshipData !== undefined && relationshipData !== null) {
+                    // If it's an object with properties, consider it populated
+                    if (typeof relationshipData === 'object' && Object.keys(relationshipData).length > 0) {
+                        populatedCount++;
+                    }
+                    // If it's a non-null primitive value, also consider it populated
+                    else if (typeof relationshipData !== 'object') {
+                        populatedCount++;
+                    }
+                    // If it's an empty object or array, consider it partially populated
+                    else {
+                        partiallyPopulatedCount++;
+                    }
+                }
+                // Also check if the record has any nested relationship data
+                // This handles cases where the selection set includes nested fields like "table.id", "table.name"
+                const hasNestedRelationshipData = this.hasNestedRelationshipData(record, config.fieldName);
+                if (hasNestedRelationshipData) {
+                    populatedCount++;
+                }
             }
-            return this.client.models[modelName].observeQuery(queryOptions);
+            // Consider the validation successful if we have any populated or partially populated records
+            const totalValidRecords = populatedCount + partiallyPopulatedCount;
+            if (totalValidRecords === 0) {
+                // Log detailed information about what we found
+                this.errorHandler.logSelectionSetError(SelectionSetErrorType.FIELD_NOT_FOUND, `No records have relationship field '${config.fieldName}' populated`, config, undefined, {
+                    method: 'validateRelationshipFieldPopulation',
+                    recordCount: records.length,
+                    populatedCount,
+                    partiallyPopulatedCount,
+                    sampleRecord: records[0] ? Object.keys(records[0]) : [],
+                    sampleRecordData: records[0] ? records[0] : null,
+                    fieldName: config.fieldName,
+                    relationshipFieldValue: records[0] ? records[0][config.fieldName] : undefined
+                });
+                console.warn(`AmplifyModelService: No records have relationship field '${config.fieldName}' populated`, {
+                    config,
+                    recordCount: records.length,
+                    sampleRecord: records[0],
+                    sampleRelationshipValue: records[0] ? records[0][config.fieldName] : undefined
+                });
+                return false;
+            }
+            console.log(`AmplifyModelService: Relationship field validation successful: ${populatedCount}/${records.length} records fully populated, ${partiallyPopulatedCount} partially populated for '${config.fieldName}' field`);
+            return true;
         }
-        else {
-            console.error(`Relationship model ${modelName} not found in client`);
-            return null;
+        catch (error) {
+            this.errorHandler.logSelectionSetError(SelectionSetErrorType.GRAPHQL_ERROR, `Error validating relationship field population: ${error instanceof Error ? error.message : String(error)}`, config, undefined, {
+                method: 'validateRelationshipFieldPopulation',
+                originalError: {
+                    message: error instanceof Error ? error.message : String(error),
+                    stack: error instanceof Error ? error.stack : undefined
+                }
+            });
+            console.error('AmplifyModelService: Error validating relationship field population:', error);
+            return false;
+        }
+    }
+    /**
+     * Check if a record has nested relationship data based on field patterns
+     * This helps validate cases where selection sets use nested field access like "table.id", "table.name"
+     */
+    hasNestedRelationshipData(record, fieldName) {
+        if (!record || typeof record !== 'object') {
+            return false;
+        }
+        // Look for any fields that start with the relationship field name followed by a dot
+        const nestedFieldPattern = `${fieldName}.`;
+        for (const key of Object.keys(record)) {
+            if (key.startsWith(nestedFieldPattern)) {
+                const value = record[key];
+                if (value !== undefined && value !== null) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    /**
+     * Log query attempt details
+     */
+    logQueryAttempt(config, selectionSet, retryAttempt, previousErrors) {
+        console.log('AmplifyModelService: Query attempt details:', {
+            attempt: retryAttempt + 1,
+            config: {
+                relationshipModelName: config.relationshipModelName,
+                fieldName: config.fieldName
+            },
+            selectionSet,
+            previousErrors: previousErrors.length,
+            timestamp: new Date().toISOString()
+        });
+    }
+    /**
+     * Log successful query details
+     */
+    logQuerySuccess(config, selectionSet, retryAttempt, result) {
+        const recordCount = result?.data ? (Array.isArray(result.data) ? result.data.length : 1) : 0;
+        console.log('AmplifyModelService: Query successful:', {
+            attempt: retryAttempt + 1,
+            config: {
+                relationshipModelName: config.relationshipModelName,
+                fieldName: config.fieldName
+            },
+            selectionSet,
+            recordCount,
+            timestamp: new Date().toISOString()
+        });
+    }
+    /**
+     * Log query error details
+     */
+    logQueryError(config, error, retryAttempt) {
+        console.error('AmplifyModelService: Query error details:', {
+            attempt: retryAttempt + 1,
+            config: {
+                relationshipModelName: config.relationshipModelName,
+                baseModelName: config.baseModelName,
+                fieldName: config.fieldName,
+                associatedWith: config.associatedWith
+            },
+            error: {
+                message: error instanceof Error ? error.message : String(error),
+                type: typeof error,
+                name: error instanceof Error ? error.name : undefined
+            },
+            timestamp: new Date().toISOString()
+        });
+    }
+    /**
+     * Log final failure when all retries are exhausted
+     * Enhanced with comprehensive error context and recovery suggestions
+     */
+    logFinalFailure(config, allErrors, finalError) {
+        try {
+            const errorSummary = {
+                config: {
+                    relationshipModelName: config.relationshipModelName,
+                    baseModelName: config.baseModelName,
+                    fieldName: config.fieldName,
+                    associatedWith: config.associatedWith
+                },
+                totalAttempts: allErrors.length + 1,
+                allErrors,
+                finalError: {
+                    message: finalError instanceof Error ? finalError.message : String(finalError),
+                    type: typeof finalError,
+                    name: finalError instanceof Error ? finalError.name : undefined
+                },
+                timestamp: new Date().toISOString(),
+                suggestions: [
+                    'Check if the relationship model exists in your Amplify schema',
+                    'Verify that the field name matches the relationship field in your model',
+                    'Ensure the relationship is properly configured in your GraphQL schema',
+                    'Check if there are any authorization rules preventing access to the relationship data'
+                ]
+            };
+            // Log using ErrorHandlerService for comprehensive tracking
+            this.errorHandler.logFailedRecovery(this.errorHandler.logSelectionSetError(SelectionSetErrorType.GRAPHQL_ERROR, 'All retry attempts failed for relationship query', config, undefined, {
+                method: 'logFinalFailure',
+                errorSummary
+            }), allErrors, finalError);
+            console.error('AmplifyModelService: All retry attempts failed:', errorSummary);
+        }
+        catch (loggingError) {
+            // Even logging failed - use basic console error
+            console.error('AmplifyModelService: Critical error - failed to log final failure:', {
+                originalError: finalError,
+                loggingError,
+                config: config?.fieldName || 'unknown'
+            });
         }
     }
     createItemPromise(model, payload) {
@@ -559,7 +3028,7 @@ class AmplifyModelService {
             return null;
         }
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: AmplifyModelService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: AmplifyModelService, deps: [{ token: SelectionSetGeneratorService }, { token: ErrorHandlerService }], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: AmplifyModelService, providedIn: 'root' });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: AmplifyModelService, decorators: [{
@@ -567,7 +3036,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImpo
             args: [{
                     providedIn: 'root'
                 }]
-        }], ctorParameters: () => [] });
+        }], ctorParameters: () => [{ type: SelectionSetGeneratorService }, { type: ErrorHandlerService }] });
 
 class DynamicFormQuestionComponent {
     rootFormGroup;
@@ -798,46 +3267,441 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImpo
 // import outputs from '../../../../amplify_outputs.json';
 class DynamicRelationshipBuilderComponent {
     ams;
+    errorHandler;
     m2m;
     item;
     model;
-    m2mItems;
-    constructor(ams) {
+    m2mItems = [];
+    errorMessage = '';
+    isLoading = false;
+    constructor(ams, errorHandler) {
         this.ams = ams;
+        this.errorHandler = errorHandler;
     }
     modelItem; // = signal('');
     dialog = inject(MatDialog);
     ngOnInit() {
-        console.log('DynamicRelationshipBuilderComponent model', this.m2m);
-        this.listItems();
-        this.setCreateSubscription();
+        try {
+            console.log('DynamicRelationshipBuilderComponent initializing with m2m config:', this.m2m);
+            // Validate required inputs with comprehensive error logging
+            if (!this.m2m) {
+                const error = this.errorHandler.logSelectionSetError(SelectionSetErrorType.INVALID_CONFIGURATION, 'Relationship configuration (m2m) is missing', undefined, undefined, {
+                    component: 'DynamicRelationshipBuilderComponent',
+                    method: 'ngOnInit',
+                    hasItem: !!this.item,
+                    hasModel: !!this.model
+                });
+                this.setError('Relationship configuration is missing');
+                return;
+            }
+            if (!this.item || !this.item.id) {
+                const error = this.errorHandler.logSelectionSetError(SelectionSetErrorType.INVALID_CONFIGURATION, 'Item data is missing or invalid (no ID)', this.m2m, undefined, {
+                    component: 'DynamicRelationshipBuilderComponent',
+                    method: 'ngOnInit',
+                    hasItem: !!this.item,
+                    itemId: this.item?.id,
+                    hasModel: !!this.model
+                });
+                this.setError('Item data is missing or invalid');
+                return;
+            }
+            // Validate m2m configuration structure
+            const requiredM2MFields = ['relationshipModelName', 'fieldName', 'baseModelName', 'associatedWith'];
+            const missingFields = requiredM2MFields.filter(field => !this.m2m[field]);
+            if (missingFields.length > 0) {
+                const error = this.errorHandler.logSelectionSetError(SelectionSetErrorType.INVALID_CONFIGURATION, `M2M configuration is missing required fields: ${missingFields.join(', ')}`, this.m2m, undefined, {
+                    component: 'DynamicRelationshipBuilderComponent',
+                    method: 'ngOnInit',
+                    missingFields,
+                    providedFields: Object.keys(this.m2m || {})
+                });
+                this.setError(`Configuration is incomplete: missing ${missingFields.join(', ')}`);
+                return;
+            }
+            this.clearError();
+            console.log('DynamicRelationshipBuilderComponent: Configuration validated successfully');
+            // Initialize relationship data loading
+            this.listItems();
+            this.setCreateSubscription();
+        }
+        catch (error) {
+            const componentError = this.errorHandler.logSelectionSetError(SelectionSetErrorType.GRAPHQL_ERROR, `Unexpected error during component initialization: ${error instanceof Error ? error.message : String(error)}`, this.m2m, undefined, {
+                component: 'DynamicRelationshipBuilderComponent',
+                method: 'ngOnInit',
+                originalError: {
+                    message: error instanceof Error ? error.message : String(error),
+                    stack: error instanceof Error ? error.stack : undefined
+                }
+            });
+            console.error('DynamicRelationshipBuilderComponent: Critical initialization error:', error);
+            this.setError('Failed to initialize relationship component');
+        }
+    }
+    /**
+     * Set error message and clear loading state
+     * Enhanced with comprehensive error context logging
+     */
+    setError(message, additionalContext) {
+        try {
+            this.errorMessage = message;
+            this.isLoading = false;
+            // Log error with context using ErrorHandlerService
+            this.errorHandler.logSelectionSetError(SelectionSetErrorType.GRAPHQL_ERROR, `Component error: ${message}`, this.m2m, undefined, {
+                component: 'DynamicRelationshipBuilderComponent',
+                method: 'setError',
+                userMessage: message,
+                componentState: {
+                    hasM2M: !!this.m2m,
+                    hasItem: !!this.item,
+                    itemId: this.item?.id,
+                    m2mItemsCount: Array.isArray(this.m2mItems) ? this.m2mItems.length : 0,
+                    isLoading: this.isLoading
+                },
+                ...additionalContext
+            });
+            console.error('DynamicRelationshipBuilderComponent error:', {
+                message,
+                context: additionalContext,
+                timestamp: new Date().toISOString()
+            });
+        }
+        catch (loggingError) {
+            // Fallback if even error logging fails
+            console.error('DynamicRelationshipBuilderComponent: Critical error in setError:', {
+                originalMessage: message,
+                loggingError,
+                timestamp: new Date().toISOString()
+            });
+            this.errorMessage = message;
+            this.isLoading = false;
+        }
+    }
+    /**
+     * Clear error message and log recovery
+     */
+    clearError() {
+        if (this.errorMessage) {
+            console.log('DynamicRelationshipBuilderComponent: Clearing previous error:', this.errorMessage);
+        }
+        this.errorMessage = '';
+    }
+    /**
+     * Get display name for a relationship item, handling various field names
+     */
+    getDisplayName(relationshipItem) {
+        if (!relationshipItem) {
+            return 'Unknown item';
+        }
+        // Try common display field names
+        return relationshipItem.name ||
+            relationshipItem.title ||
+            relationshipItem.label ||
+            relationshipItem.displayName ||
+            `Item ${relationshipItem.id || 'Unknown'}`;
+    }
+    /**
+     * Get display name for items with partial or missing relationship data
+     */
+    getPartialDisplayName(item) {
+        if (!item) {
+            return 'Unknown item';
+        }
+        // If we have an ID, show it
+        if (item.id) {
+            return `Item ${item.id} (incomplete data)`;
+        }
+        return 'Incomplete relationship data';
+    }
+    /**
+     * Check if an item has complete relationship data
+     */
+    hasCompleteRelationshipData(item) {
+        if (!item || !this.m2m?.fieldName) {
+            return false;
+        }
+        const relationshipData = item[this.m2m.fieldName];
+        return relationshipData && (relationshipData.name || relationshipData.title || relationshipData.id);
+    }
+    /**
+     * Check if an item has partial relationship data (item exists but relationship data is incomplete)
+     */
+    hasPartialRelationshipData(item) {
+        if (!item || !item.id) {
+            return false;
+        }
+        return !this.hasCompleteRelationshipData(item);
+    }
+    /**
+     * Get loading state indicator for relationship data
+     */
+    getRelationshipLoadingState(item) {
+        if (!item) {
+            return 'missing';
+        }
+        if (this.isLoading) {
+            return 'loading';
+        }
+        if (this.hasCompleteRelationshipData(item)) {
+            return 'complete';
+        }
+        if (item.id) {
+            return 'partial';
+        }
+        return 'missing';
+    }
+    /**
+     * Get appropriate CSS class for relationship item based on data completeness
+     */
+    getRelationshipItemClass(item) {
+        const state = this.getRelationshipLoadingState(item);
+        return `relationship-item relationship-item--${state}`;
+    }
+    /**
+     * Get tooltip text for relationship items based on their data state
+     */
+    getRelationshipTooltip(item) {
+        const state = this.getRelationshipLoadingState(item);
+        switch (state) {
+            case 'complete':
+                return 'Complete relationship data loaded';
+            case 'partial':
+                return 'Relationship exists but some data is missing or failed to load';
+            case 'loading':
+                return 'Loading relationship data...';
+            case 'missing':
+                return 'No relationship data available';
+            default:
+                return '';
+        }
+    }
+    /**
+     * Get summary of data states for all relationship items
+     */
+    getDataStateSummary() {
+        if (!Array.isArray(this.m2mItems)) {
+            return {
+                completeCount: 0,
+                partialCount: 0,
+                missingCount: 0,
+                hasPartialOrMissing: false
+            };
+        }
+        let completeCount = 0;
+        let partialCount = 0;
+        let missingCount = 0;
+        this.m2mItems.forEach(item => {
+            const state = this.getRelationshipLoadingState(item);
+            switch (state) {
+                case 'complete':
+                    completeCount++;
+                    break;
+                case 'partial':
+                    partialCount++;
+                    break;
+                case 'missing':
+                    missingCount++;
+                    break;
+            }
+        });
+        return {
+            completeCount,
+            partialCount,
+            missingCount,
+            hasPartialOrMissing: partialCount > 0 || missingCount > 0
+        };
     }
     async perhapsAddM2MItem(item) {
-        let m2mItem = { id: item.id };
-        const { data: retItem } = await item[this.m2m.fieldName]();
-        m2mItem[this.m2m.fieldName] = retItem;
-        let existingInd = this.m2mItems.findIndex((x) => x.id == item.id);
-        if (existingInd > -1) {
-            if (!this.m2mItems[existingInd][this.m2m.fieldName]) {
-                console.log('would delete existing', this.m2mItems[existingInd]);
-                this.m2mItems.splice(existingInd, 1);
+        try {
+            if (!item || !item.id) {
+                console.warn('Invalid item received in perhapsAddM2MItem:', item);
+                return;
+            }
+            let m2mItem = { id: item.id };
+            // Safely attempt to get relationship data
+            if (this.m2m?.fieldName && typeof item[this.m2m.fieldName] === 'function') {
+                try {
+                    const { data: retItem } = await item[this.m2m.fieldName]();
+                    m2mItem[this.m2m.fieldName] = retItem;
+                }
+                catch (relationshipError) {
+                    console.warn('Failed to load relationship data for item:', item.id, relationshipError);
+                    // Keep the item but mark it as having incomplete data
+                    m2mItem[this.m2m.fieldName] = null;
+                }
             }
+            else {
+                console.warn('Invalid fieldName or item method for relationship:', this.m2m?.fieldName);
+                m2mItem[this.m2m.fieldName] = null;
+            }
+            // Ensure m2mItems is initialized as array
+            if (!Array.isArray(this.m2mItems)) {
+                this.m2mItems = [];
+            }
+            let existingInd = this.m2mItems.findIndex((x) => x?.id === item.id);
+            if (existingInd > -1) {
+                if (!this.m2mItems[existingInd][this.m2m.fieldName]) {
+                    console.log('Removing existing item with no relationship data', this.m2mItems[existingInd]);
+                    this.m2mItems.splice(existingInd, 1);
+                }
+            }
+            this.m2mItems.push(m2mItem);
+        }
+        catch (error) {
+            console.error('Error in perhapsAddM2MItem:', error);
+            // Don't let individual item errors break the entire component
         }
-        this.m2mItems.push(m2mItem);
-        //console.log('perhapsAddM2MItem', item, 'm2m', this.m2m);
     }
     setCreateSubscription() {
-        this.ams.setRelatedSub(this.m2m, this.item.id)?.subscribe({
-            next: (data) => this.perhapsAddM2MItem(data), //(console.log('setRelatedSub m2mItems', this.m2mItems, 'data', data),
-            error: (error) => console.warn(error),
-        });
+        try {
+            if (!this.m2m || !this.item?.id) {
+                console.warn('Cannot set subscription: missing m2m or item.id');
+                return;
+            }
+            const subscription = this.ams.setRelatedSub(this.m2m, this.item.id);
+            if (subscription) {
+                subscription.subscribe({
+                    next: (data) => {
+                        this.perhapsAddM2MItem(data);
+                    },
+                    error: (error) => {
+                        console.warn('Subscription error for related items:', error);
+                        this.setError('Failed to receive real-time updates for relationships');
+                    },
+                });
+            }
+            else {
+                console.warn('Failed to create subscription for related items');
+            }
+        }
+        catch (error) {
+            console.error('Error setting up subscription:', error);
+            this.setError('Failed to set up real-time updates');
+        }
     }
     listItems() {
-        this.ams.getRelatedItems(this.m2m, this.item.id)?.subscribe({
-            next: ({ items, isSynced }) => {
-                this.m2mItems = items;
-            },
-        });
+        try {
+            if (!this.m2m || !this.item?.id) {
+                const error = 'Cannot load relationships: missing configuration or item data';
+                this.setError(error, {
+                    method: 'listItems',
+                    hasM2M: !!this.m2m,
+                    hasItem: !!this.item,
+                    itemId: this.item?.id
+                });
+                return;
+            }
+            this.isLoading = true;
+            this.clearError();
+            console.log('DynamicRelationshipBuilderComponent: Loading relationship items for:', {
+                relationshipModel: this.m2m.relationshipModelName,
+                fieldName: this.m2m.fieldName,
+                itemId: this.item.id
+            });
+            const observable = this.ams.getRelatedItems(this.m2m, this.item.id);
+            if (observable) {
+                observable.subscribe({
+                    next: ({ items, isSynced }) => {
+                        try {
+                            this.isLoading = false;
+                            // Ensure items is an array
+                            if (Array.isArray(items)) {
+                                this.m2mItems = items;
+                                console.log('DynamicRelationshipBuilderComponent: Successfully loaded relationship items:', {
+                                    count: items.length,
+                                    isSynced,
+                                    sampleItem: items[0] ? Object.keys(items[0]) : []
+                                });
+                            }
+                            else {
+                                console.warn('DynamicRelationshipBuilderComponent: Received non-array items:', items);
+                                this.m2mItems = [];
+                                this.errorHandler.logSelectionSetError(SelectionSetErrorType.GRAPHQL_ERROR, 'Received non-array items from relationship query', this.m2m, undefined, {
+                                    component: 'DynamicRelationshipBuilderComponent',
+                                    method: 'listItems',
+                                    receivedType: typeof items,
+                                    receivedValue: items,
+                                    isSynced
+                                });
+                            }
+                            // Analyze data quality
+                            const dataStateSummary = this.getDataStateSummary();
+                            if (dataStateSummary.hasPartialOrMissing) {
+                                console.warn('DynamicRelationshipBuilderComponent: Some relationship data is incomplete:', dataStateSummary);
+                            }
+                        }
+                        catch (processingError) {
+                            this.isLoading = false;
+                            const error = `Error processing relationship data: ${processingError instanceof Error ? processingError.message : String(processingError)}`;
+                            this.setError('Failed to process relationship data', {
+                                method: 'listItems',
+                                step: 'data_processing',
+                                originalError: {
+                                    message: processingError instanceof Error ? processingError.message : String(processingError),
+                                    stack: processingError instanceof Error ? processingError.stack : undefined
+                                }
+                            });
+                            this.m2mItems = [];
+                        }
+                    },
+                    error: (error) => {
+                        this.isLoading = false;
+                        const errorMessage = error instanceof Error ? error.message : String(error);
+                        console.error('DynamicRelationshipBuilderComponent: Error loading relationship items:', error);
+                        // Log comprehensive error details
+                        this.errorHandler.logSelectionSetError(SelectionSetErrorType.GRAPHQL_ERROR, `Failed to load relationship data: ${errorMessage}`, this.m2m, undefined, {
+                            component: 'DynamicRelationshipBuilderComponent',
+                            method: 'listItems',
+                            step: 'observable_error',
+                            originalError: {
+                                message: errorMessage,
+                                stack: error instanceof Error ? error.stack : undefined,
+                                name: error instanceof Error ? error.name : undefined
+                            },
+                            itemId: this.item.id
+                        });
+                        this.setError('Failed to load relationship data. Please try refreshing the page.', {
+                            method: 'listItems',
+                            originalError: errorMessage
+                        });
+                        // Initialize empty array so component doesn't break
+                        this.m2mItems = [];
+                    }
+                });
+            }
+            else {
+                this.isLoading = false;
+                this.errorHandler.logSelectionSetError(SelectionSetErrorType.GRAPHQL_ERROR, 'AmplifyModelService returned null observable for relationship query', this.m2m, undefined, {
+                    component: 'DynamicRelationshipBuilderComponent',
+                    method: 'listItems',
+                    step: 'observable_creation',
+                    itemId: this.item.id
+                });
+                this.setError('Unable to create relationship query', {
+                    method: 'listItems',
+                    step: 'observable_creation'
+                });
+                this.m2mItems = [];
+            }
+        }
+        catch (error) {
+            this.isLoading = false;
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error('DynamicRelationshipBuilderComponent: Critical error in listItems:', error);
+            this.errorHandler.logSelectionSetError(SelectionSetErrorType.GRAPHQL_ERROR, `Critical error in listItems: ${errorMessage}`, this.m2m, undefined, {
+                component: 'DynamicRelationshipBuilderComponent',
+                method: 'listItems',
+                step: 'critical_error',
+                originalError: {
+                    message: errorMessage,
+                    stack: error instanceof Error ? error.stack : undefined
+                }
+            });
+            this.setError('An unexpected error occurred while loading relationships', {
+                method: 'listItems',
+                originalError: errorMessage
+            });
+            this.m2mItems = [];
+        }
     }
     /**
     Customize this function to include all desired models from your file
@@ -848,44 +3712,111 @@ class DynamicRelationshipBuilderComponent {
         this.modelItem = signal(this.ams.getEmptyObjectForModel(mdl), ...(ngDevMode ? [{ debugName: "modelItem" }] : []));
     }
     async deleteRelatedItem(item) {
-        console.log('deleteRelatedItem for item', item, 'm2m', this.m2m);
-        //this.ams.deleteRelationship(this.m2m.relationshipModelName, item.id);
-        await this.ams.deleteRelationship(this.m2m.relationshipModelName, item.id);
+        try {
+            if (!item || !item.id) {
+                console.warn('Cannot delete item: invalid item data', item);
+                this.setError('Cannot delete item: invalid data');
+                return;
+            }
+            if (!this.m2m?.relationshipModelName) {
+                console.warn('Cannot delete item: missing relationship model name');
+                this.setError('Cannot delete item: missing configuration');
+                return;
+            }
+            console.log('deleteRelatedItem for item', item, 'm2m', this.m2m);
+            await this.ams.deleteRelationship(this.m2m.relationshipModelName, item.id);
+            // Remove item from local array on successful deletion
+            if (Array.isArray(this.m2mItems)) {
+                const index = this.m2mItems.findIndex(x => x?.id === item.id);
+                if (index > -1) {
+                    this.m2mItems.splice(index, 1);
+                }
+            }
+        }
+        catch (error) {
+            console.error('Error deleting relationship item:', error);
+            this.setError('Failed to delete relationship. Please try again.');
+        }
     }
     openDialog(rel) {
-        console.log('openDialog clicked for rel', rel);
-        this.setModelItem(rel.partnerModelName);
-        const dialogRef = this.dialog.open(AddRelationshipDialogComponent, {
-            data: { rel: rel, modelItem: this.modelItem(), selectedItems: this.m2mItems },
-        });
-        dialogRef.afterClosed().subscribe(result => {
-            if (result)
-                this.handleDialogResult(result, rel);
-        });
+        try {
+            if (!rel) {
+                console.warn('Cannot open dialog: missing relationship configuration');
+                this.setError('Cannot add relationship: missing configuration');
+                return;
+            }
+            console.log('openDialog clicked for rel', rel);
+            this.setModelItem(rel.partnerModelName);
+            const dialogRef = this.dialog.open(AddRelationshipDialogComponent, {
+                data: { rel: rel, modelItem: this.modelItem(), selectedItems: this.m2mItems || [] },
+            });
+            dialogRef.afterClosed().subscribe({
+                next: (result) => {
+                    if (result) {
+                        this.handleDialogResult(result, rel);
+                    }
+                },
+                error: (error) => {
+                    console.error('Dialog error:', error);
+                    this.setError('An error occurred while adding the relationship');
+                }
+            });
+        }
+        catch (error) {
+            console.error('Error opening dialog:', error);
+            this.setError('Failed to open relationship dialog');
+        }
     }
     handleDialogResult(result, rel) {
-        if (!result)
-            return;
-        console.log('handleDialogResult', result, 'rel', rel);
-        if (result !== undefined) {
-            this.modelItem.set(result);
+        try {
+            if (!result) {
+                return;
+            }
+            if (!rel || !this.item?.id) {
+                console.warn('Cannot handle dialog result: missing relationship or item data');
+                this.setError('Cannot create relationship: missing data');
+                return;
+            }
+            console.log('handleDialogResult', result, 'rel', rel);
+            if (result !== undefined) {
+                this.modelItem.set(result);
+            }
+            let relIdName = rel.partnerModelName?.toLowerCase() + 'Id';
+            let thisIdName = rel.baseModelName?.toLowerCase() + 'Id';
+            if (!relIdName || !thisIdName) {
+                console.warn('Cannot determine relationship field names');
+                this.setError('Cannot create relationship: invalid configuration');
+                return;
+            }
+            let newRelObj = {};
+            newRelObj[relIdName] = result.id;
+            newRelObj[thisIdName] = this.item.id;
+            const createPromise = this.ams.createRelationship(rel.relationshipModelName, newRelObj);
+            if (createPromise) {
+                createPromise.catch((error) => {
+                    console.error('Error creating relationship:', error);
+                    this.setError('Failed to create relationship. Please try again.');
+                });
+            }
+            else {
+                console.warn('Failed to create relationship: service returned null');
+                this.setError('Failed to create relationship. Please try again.');
+            }
+        }
+        catch (error) {
+            console.error('Error handling dialog result:', error);
+            this.setError('An error occurred while creating the relationship');
         }
-        let relIdName = rel.partnerModelName.toLowerCase() + 'Id';
-        let thisIdName = rel.baseModelName.toLowerCase() + 'Id';
-        let newRelObj = {};
-        newRelObj[relIdName] = result.id;
-        newRelObj[thisIdName] = this.item.id;
-        this.ams.createRelationship(rel.relationshipModelName, newRelObj);
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: DynamicRelationshipBuilderComponent, deps: [{ token: AmplifyModelService }], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "20.3.15", type: DynamicRelationshipBuilderComponent, isStandalone: true, selector: "snteam-dynamic-relationship-builder", inputs: { m2m: "m2m", item: "item", model: "model" }, ngImport: i0, template: "<div class=\"record-relationship-holder\">\n  <div class=\"relationship-type\">\n    <mat-toolbar>\n      <span>{{m2m.partnerModelName}} Management</span>\n      <span class=\"rel-title-spacer\"></span>\n      <button mat-icon-button attr.aria-label=\"Add {{m2m.name}}\" (click)=\"openDialog(m2m)\">\n        <mat-icon>add</mat-icon>\n      </button>\n    </mat-toolbar>\n    @if(m2mItems && m2mItems.length > 0){\n    <mat-list>\n      @for (item of m2mItems; track item?.id) {\n      @if(item[m2m.fieldName]){\n      <mat-list-item>\n        <span matListItemTitle>{{item[m2m.fieldName].name || item[m2m.fieldName].title}}</span>\n        <button mat-icon-button (click)=\"deleteRelatedItem(item)\" matListItemMeta>\n          <mat-icon>delete</mat-icon>\n        </button>\n      </mat-list-item>\n      }\n      }\n    </mat-list>\n    }\n    @else {\n    Add your first {{m2m.partnerModelName}}\n    }\n  </div>\n</div>", styles: [".relationship-type{margin-top:20px}.rel-title-spacer{flex:1 1 auto}mat-toolbar button{background:transparent;color:#000}\n"], dependencies: [{ kind: "ngmodule", type: MatToolbarModule }, { kind: "component", type: i2.MatToolbar, selector: "mat-toolbar", inputs: ["color"], exportAs: ["matToolbar"] }, { kind: "ngmodule", type: MatButtonModule }, { kind: "component", type: i3$3.MatIconButton, selector: "button[mat-icon-button], a[mat-icon-button], button[matIconButton], a[matIconButton]", exportAs: ["matButton", "matAnchor"] }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i4$1.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "ngmodule", type: MatFormFieldModule }, { kind: "ngmodule", type: MatInputModule }, { kind: "ngmodule", type: MatListModule }, { kind: "component", type: i5$1.MatList, selector: "mat-list", exportAs: ["matList"] }, { kind: "component", type: i5$1.MatListItem, selector: "mat-list-item, a[mat-list-item], button[mat-list-item]", inputs: ["activated"], exportAs: ["matListItem"] }, { kind: "directive", type: i5$1.MatListItemTitle, selector: "[matListItemTitle]" }, { kind: "directive", type: i5$1.MatListItemMeta, selector: "[matListItemMeta]" }, { kind: "ngmodule", type: FormsModule }, { kind: "ngmodule", type: CommonModule }] });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: DynamicRelationshipBuilderComponent, deps: [{ token: AmplifyModelService }, { token: ErrorHandlerService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "20.3.15", type: DynamicRelationshipBuilderComponent, isStandalone: true, selector: "snteam-dynamic-relationship-builder", inputs: { m2m: "m2m", item: "item", model: "model" }, ngImport: i0, template: "<div class=\"record-relationship-holder\">\n  <div class=\"relationship-type\">\n    <mat-toolbar>\n      <span>{{m2m?.partnerModelName || 'Unknown'}} Management</span>\n      <span class=\"rel-title-spacer\"></span>\n      <button mat-icon-button [attr.aria-label]=\"'Add ' + (m2m?.name || 'item')\" (click)=\"openDialog(m2m)\" [disabled]=\"!m2m\">\n        <mat-icon>add</mat-icon>\n      </button>\n    </mat-toolbar>\n    \n    <!-- Error message display -->\n    @if (errorMessage) {\n      <div class=\"error-message\" role=\"alert\">\n        <mat-icon>error</mat-icon>\n        <span>{{ errorMessage }}</span>\n      </div>\n    }\n    \n    <!-- Loading state -->\n    @if (isLoading) {\n      <div class=\"loading-message\">\n        <mat-icon>hourglass_empty</mat-icon>\n        <span>Loading relationships...</span>\n      </div>\n    }\n    \n    <!-- Relationship items display -->\n    @if (m2mItems && m2mItems.length > 0) {\n      <mat-list>\n        @for (item of m2mItems; track item?.id) {\n          <mat-list-item [class]=\"getRelationshipItemClass(item)\" [title]=\"getRelationshipTooltip(item)\">\n            @if (hasCompleteRelationshipData(item)) {\n              <!-- Complete relationship data -->\n              <span matListItemTitle>{{ getDisplayName(item[m2m.fieldName]) }}</span>\n              <span matListItemLine class=\"relationship-status complete\">Complete data</span>\n              <button mat-icon-button (click)=\"deleteRelatedItem(item)\" matListItemMeta [attr.aria-label]=\"'Delete ' + getDisplayName(item[m2m.fieldName])\">\n                <mat-icon>delete</mat-icon>\n              </button>\n            } @else if (hasPartialRelationshipData(item)) {\n              <!-- Partial relationship data -->\n              <span matListItemTitle class=\"partial-data\">\n                {{ getPartialDisplayName(item) }}\n                <mat-icon class=\"warning-icon\" title=\"Incomplete relationship data\">warning</mat-icon>\n              </span>\n              <span matListItemLine class=\"relationship-status partial\">Partial data - some information may be missing</span>\n              <button mat-icon-button (click)=\"deleteRelatedItem(item)\" matListItemMeta [attr.aria-label]=\"'Delete incomplete item'\">\n                <mat-icon>delete</mat-icon>\n              </button>\n            } @else {\n              <!-- Missing or invalid relationship data -->\n              <span matListItemTitle class=\"missing-data\">\n                Invalid relationship data\n                <mat-icon class=\"error-icon\" title=\"Invalid or missing data\">error</mat-icon>\n              </span>\n              <span matListItemLine class=\"relationship-status missing\">Data could not be loaded</span>\n              <button mat-icon-button (click)=\"deleteRelatedItem(item)\" matListItemMeta [attr.aria-label]=\"'Delete invalid item'\">\n                <mat-icon>delete</mat-icon>\n              </button>\n            }\n          </mat-list-item>\n        }\n      </mat-list>\n      \n      <!-- Summary of data states -->\n      @if (getDataStateSummary().hasPartialOrMissing) {\n        <div class=\"data-summary\">\n          <mat-icon>info</mat-icon>\n          <span>\n            {{ getDataStateSummary().completeCount }} of {{ m2mItems.length }} relationships loaded completely.\n            @if (getDataStateSummary().partialCount > 0) {\n              {{ getDataStateSummary().partialCount }} have partial data.\n            }\n            @if (getDataStateSummary().missingCount > 0) {\n              {{ getDataStateSummary().missingCount }} failed to load.\n            }\n          </span>\n        </div>\n      }\n    } @else if (!isLoading && !errorMessage) {\n      <div class=\"empty-state\">\n        Add your first {{ m2m?.partnerModelName || 'item' }}\n      </div>\n    }\n  </div>\n</div>", styles: [".relationship-type{margin-top:20px}.rel-title-spacer{flex:1 1 auto}mat-toolbar button{background:transparent;color:#000}.error-message{display:flex;align-items:center;gap:8px;padding:12px;background-color:#ffebee;color:#c62828;border-left:4px solid #c62828;margin:8px 0}.loading-message{display:flex;align-items:center;gap:8px;padding:12px;background-color:#f5f5f5;color:#666;margin:8px 0}.partial-data{display:flex;align-items:center;gap:4px;color:#ff9800}.missing-data{display:flex;align-items:center;gap:4px;color:#f44336}.warning-icon{font-size:16px;width:16px;height:16px;color:#ff9800}.error-icon{font-size:16px;width:16px;height:16px;color:#f44336}.empty-state{padding:20px;text-align:center;color:#666;font-style:italic}.relationship-status{font-size:12px;opacity:.7}.relationship-status.complete{color:#4caf50}.relationship-status.partial{color:#ff9800}.relationship-status.missing{color:#f44336}.relationship-item--complete{border-left:3px solid #4caf50}.relationship-item--partial{border-left:3px solid #ff9800;background-color:#fff8e1}.relationship-item--missing{border-left:3px solid #f44336;background-color:#ffebee}.relationship-item--loading{border-left:3px solid #2196f3;background-color:#e3f2fd}.data-summary{display:flex;align-items:center;gap:8px;padding:12px;background-color:#e8f5e8;color:#2e7d32;border-radius:4px;margin:8px 0;font-size:14px}\n"], dependencies: [{ kind: "ngmodule", type: MatToolbarModule }, { kind: "component", type: i3$4.MatToolbar, selector: "mat-toolbar", inputs: ["color"], exportAs: ["matToolbar"] }, { kind: "ngmodule", type: MatButtonModule }, { kind: "component", type: i3$3.MatIconButton, selector: "button[mat-icon-button], a[mat-icon-button], button[matIconButton], a[matIconButton]", exportAs: ["matButton", "matAnchor"] }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i5$1.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "ngmodule", type: MatFormFieldModule }, { kind: "ngmodule", type: MatInputModule }, { kind: "ngmodule", type: MatListModule }, { kind: "component", type: i6$1.MatList, selector: "mat-list", exportAs: ["matList"] }, { kind: "component", type: i6$1.MatListItem, selector: "mat-list-item, a[mat-list-item], button[mat-list-item]", inputs: ["activated"], exportAs: ["matListItem"] }, { kind: "directive", type: i6$1.MatListItemLine, selector: "[matListItemLine]" }, { kind: "directive", type: i6$1.MatListItemTitle, selector: "[matListItemTitle]" }, { kind: "directive", type: i6$1.MatListItemMeta, selector: "[matListItemMeta]" }, { kind: "ngmodule", type: FormsModule }, { kind: "ngmodule", type: CommonModule }] });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: DynamicRelationshipBuilderComponent, decorators: [{
             type: Component,
             args: [{ selector: 'snteam-dynamic-relationship-builder', standalone: true, imports: [MatToolbarModule, MatButtonModule, MatIconModule, MatFormFieldModule, MatInputModule, MatListModule,
                         FormsModule,
-                        CommonModule], template: "<div class=\"record-relationship-holder\">\n  <div class=\"relationship-type\">\n    <mat-toolbar>\n      <span>{{m2m.partnerModelName}} Management</span>\n      <span class=\"rel-title-spacer\"></span>\n      <button mat-icon-button attr.aria-label=\"Add {{m2m.name}}\" (click)=\"openDialog(m2m)\">\n        <mat-icon>add</mat-icon>\n      </button>\n    </mat-toolbar>\n    @if(m2mItems && m2mItems.length > 0){\n    <mat-list>\n      @for (item of m2mItems; track item?.id) {\n      @if(item[m2m.fieldName]){\n      <mat-list-item>\n        <span matListItemTitle>{{item[m2m.fieldName].name || item[m2m.fieldName].title}}</span>\n        <button mat-icon-button (click)=\"deleteRelatedItem(item)\" matListItemMeta>\n          <mat-icon>delete</mat-icon>\n        </button>\n      </mat-list-item>\n      }\n      }\n    </mat-list>\n    }\n    @else {\n    Add your first {{m2m.partnerModelName}}\n    }\n  </div>\n</div>", styles: [".relationship-type{margin-top:20px}.rel-title-spacer{flex:1 1 auto}mat-toolbar button{background:transparent;color:#000}\n"] }]
-        }], ctorParameters: () => [{ type: AmplifyModelService }], propDecorators: { m2m: [{
+                        CommonModule], template: "<div class=\"record-relationship-holder\">\n  <div class=\"relationship-type\">\n    <mat-toolbar>\n      <span>{{m2m?.partnerModelName || 'Unknown'}} Management</span>\n      <span class=\"rel-title-spacer\"></span>\n      <button mat-icon-button [attr.aria-label]=\"'Add ' + (m2m?.name || 'item')\" (click)=\"openDialog(m2m)\" [disabled]=\"!m2m\">\n        <mat-icon>add</mat-icon>\n      </button>\n    </mat-toolbar>\n    \n    <!-- Error message display -->\n    @if (errorMessage) {\n      <div class=\"error-message\" role=\"alert\">\n        <mat-icon>error</mat-icon>\n        <span>{{ errorMessage }}</span>\n      </div>\n    }\n    \n    <!-- Loading state -->\n    @if (isLoading) {\n      <div class=\"loading-message\">\n        <mat-icon>hourglass_empty</mat-icon>\n        <span>Loading relationships...</span>\n      </div>\n    }\n    \n    <!-- Relationship items display -->\n    @if (m2mItems && m2mItems.length > 0) {\n      <mat-list>\n        @for (item of m2mItems; track item?.id) {\n          <mat-list-item [class]=\"getRelationshipItemClass(item)\" [title]=\"getRelationshipTooltip(item)\">\n            @if (hasCompleteRelationshipData(item)) {\n              <!-- Complete relationship data -->\n              <span matListItemTitle>{{ getDisplayName(item[m2m.fieldName]) }}</span>\n              <span matListItemLine class=\"relationship-status complete\">Complete data</span>\n              <button mat-icon-button (click)=\"deleteRelatedItem(item)\" matListItemMeta [attr.aria-label]=\"'Delete ' + getDisplayName(item[m2m.fieldName])\">\n                <mat-icon>delete</mat-icon>\n              </button>\n            } @else if (hasPartialRelationshipData(item)) {\n              <!-- Partial relationship data -->\n              <span matListItemTitle class=\"partial-data\">\n                {{ getPartialDisplayName(item) }}\n                <mat-icon class=\"warning-icon\" title=\"Incomplete relationship data\">warning</mat-icon>\n              </span>\n              <span matListItemLine class=\"relationship-status partial\">Partial data - some information may be missing</span>\n              <button mat-icon-button (click)=\"deleteRelatedItem(item)\" matListItemMeta [attr.aria-label]=\"'Delete incomplete item'\">\n                <mat-icon>delete</mat-icon>\n              </button>\n            } @else {\n              <!-- Missing or invalid relationship data -->\n              <span matListItemTitle class=\"missing-data\">\n                Invalid relationship data\n                <mat-icon class=\"error-icon\" title=\"Invalid or missing data\">error</mat-icon>\n              </span>\n              <span matListItemLine class=\"relationship-status missing\">Data could not be loaded</span>\n              <button mat-icon-button (click)=\"deleteRelatedItem(item)\" matListItemMeta [attr.aria-label]=\"'Delete invalid item'\">\n                <mat-icon>delete</mat-icon>\n              </button>\n            }\n          </mat-list-item>\n        }\n      </mat-list>\n      \n      <!-- Summary of data states -->\n      @if (getDataStateSummary().hasPartialOrMissing) {\n        <div class=\"data-summary\">\n          <mat-icon>info</mat-icon>\n          <span>\n            {{ getDataStateSummary().completeCount }} of {{ m2mItems.length }} relationships loaded completely.\n            @if (getDataStateSummary().partialCount > 0) {\n              {{ getDataStateSummary().partialCount }} have partial data.\n            }\n            @if (getDataStateSummary().missingCount > 0) {\n              {{ getDataStateSummary().missingCount }} failed to load.\n            }\n          </span>\n        </div>\n      }\n    } @else if (!isLoading && !errorMessage) {\n      <div class=\"empty-state\">\n        Add your first {{ m2m?.partnerModelName || 'item' }}\n      </div>\n    }\n  </div>\n</div>", styles: [".relationship-type{margin-top:20px}.rel-title-spacer{flex:1 1 auto}mat-toolbar button{background:transparent;color:#000}.error-message{display:flex;align-items:center;gap:8px;padding:12px;background-color:#ffebee;color:#c62828;border-left:4px solid #c62828;margin:8px 0}.loading-message{display:flex;align-items:center;gap:8px;padding:12px;background-color:#f5f5f5;color:#666;margin:8px 0}.partial-data{display:flex;align-items:center;gap:4px;color:#ff9800}.missing-data{display:flex;align-items:center;gap:4px;color:#f44336}.warning-icon{font-size:16px;width:16px;height:16px;color:#ff9800}.error-icon{font-size:16px;width:16px;height:16px;color:#f44336}.empty-state{padding:20px;text-align:center;color:#666;font-style:italic}.relationship-status{font-size:12px;opacity:.7}.relationship-status.complete{color:#4caf50}.relationship-status.partial{color:#ff9800}.relationship-status.missing{color:#f44336}.relationship-item--complete{border-left:3px solid #4caf50}.relationship-item--partial{border-left:3px solid #ff9800;background-color:#fff8e1}.relationship-item--missing{border-left:3px solid #f44336;background-color:#ffebee}.relationship-item--loading{border-left:3px solid #2196f3;background-color:#e3f2fd}.data-summary{display:flex;align-items:center;gap:8px;padding:12px;background-color:#e8f5e8;color:#2e7d32;border-radius:4px;margin:8px 0;font-size:14px}\n"] }]
+        }], ctorParameters: () => [{ type: AmplifyModelService }, { type: ErrorHandlerService }], propDecorators: { m2m: [{
                 type: Input
             }], item: [{
                 type: Input
@@ -2036,7 +4967,7 @@ class DynamicFormComponent {
             return this.form.get(question.key);
         return true;
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: DynamicFormComponent, deps: [{ token: QuestionControlService }, { token: AmplifyFormBuilderService }, { token: i3$1.Location }, { token: i4$2.ActivatedRoute }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: DynamicFormComponent, deps: [{ token: QuestionControlService }, { token: AmplifyFormBuilderService }, { token: i3$1.Location }, { token: i4$1.ActivatedRoute }], target: i0.ɵɵFactoryTarget.Component });
     static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "20.3.15", type: DynamicFormComponent, isStandalone: true, selector: "snteam-dynamic-form", inputs: { model: "model", itemId: "itemId", valueMap: "valueMap", hideRelationships: "hideRelationships", hideSaveButton: "hideSaveButton", amplifyOutputs: "amplifyOutputs", formViewId: "formViewId" }, outputs: { itemOutput: "itemOutput", submitOutput: "submitOutput", formLoaded: "formLoaded" }, ngImport: i0, template: "<div class=\"dynamic-form-holder\">\n  @if (form && questions) {\n  <form (ngSubmit)=\"onSubmit()\" [formGroup]=\"form\">\n    @for (question of questions; track question) {\n    @if (this.switchInputs.includes(question.controlType) || this.materialInputs.includes(question.controlType) || this.refInputs.includes(question.controlType)) {\n    <div class=\"form-row\">\n      <snteam-dynamic-form-question [question]=\"question\" [formGroup]=\"form\"></snteam-dynamic-form-question>\n    </div>\n    }\n    @if (this.formGroupInputs.includes(question.controlType)) {\n    <div class=\"group-row\">\n      <snteam-dynamic-form-group [question]=\"question\" [formGroup]=\"form\" [formGroupName]=\"question.key\"></snteam-dynamic-form-group>\n    </div>\n    }\n    }\n    @if (!hideSaveButton) {\n    <div class=\"form-row\">\n      <button mat-raised-button color=\"primary\" type=\"submit\" [disabled]=\"!form.valid\">Save</button>\n    </div>\n    }\n  </form>\n  } @else {\n  <div class=\"loading\">Loading...</div>\n  }\n\n  @if(item && !hideRelationships){\n  <div class=\"relationship-holder\">\n    <snteam-record-relationships [model]=\"mdl\" [id]=\"id\" [item]=\"item\" [amplifyOutputs]=\"outputs\"></snteam-record-relationships>\n  </div>\n  }\n</div>", styles: [".dynamic-form-holder{padding:20px;width:100%;display:flex;justify-content:space-between;gap:20px}form{width:100%;flex-basis:40%}.relationship-holder{flex-basis:40%}.full-width{width:100%}.form-row,.group-row{margin-top:20px}.loading{padding:20px;text-align:center;color:#666}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "component", type: DynamicFormQuestionComponent, selector: "snteam-dynamic-form-question", inputs: ["question", "formGroup"] }, { kind: "component", type: DynamicFormGroupComponent, selector: "snteam-dynamic-form-group", inputs: ["formGroupName", "question", "formGroup"] }, { kind: "component", type: RecordRelationshipsComponent, selector: "snteam-record-relationships", inputs: ["model", "id", "item", "amplifyOutputs"] }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i1.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { kind: "directive", type: i1.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i1.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "directive", type: i1.FormGroupName, selector: "[formGroupName]", inputs: ["formGroupName"] }, { kind: "ngmodule", type: MatFormFieldModule }, { kind: "ngmodule", type: MatInputModule }, { kind: "ngmodule", type: MatSelectModule }, { kind: "ngmodule", type: MatSnackBarModule }, { kind: "ngmodule", type: MatDividerModule }, { kind: "ngmodule", type: MatButtonModule }, { kind: "component", type: i3$3.MatButton, selector: "    button[matButton], a[matButton], button[mat-button], button[mat-raised-button],    button[mat-flat-button], button[mat-stroked-button], a[mat-button], a[mat-raised-button],    a[mat-flat-button], a[mat-stroked-button]  ", inputs: ["matButton"], exportAs: ["matButton", "matAnchor"] }] });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: DynamicFormComponent, decorators: [{
@@ -2055,7 +4986,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImpo
                         MatDividerModule,
                         MatButtonModule
                     ], template: "<div class=\"dynamic-form-holder\">\n  @if (form && questions) {\n  <form (ngSubmit)=\"onSubmit()\" [formGroup]=\"form\">\n    @for (question of questions; track question) {\n    @if (this.switchInputs.includes(question.controlType) || this.materialInputs.includes(question.controlType) || this.refInputs.includes(question.controlType)) {\n    <div class=\"form-row\">\n      <snteam-dynamic-form-question [question]=\"question\" [formGroup]=\"form\"></snteam-dynamic-form-question>\n    </div>\n    }\n    @if (this.formGroupInputs.includes(question.controlType)) {\n    <div class=\"group-row\">\n      <snteam-dynamic-form-group [question]=\"question\" [formGroup]=\"form\" [formGroupName]=\"question.key\"></snteam-dynamic-form-group>\n    </div>\n    }\n    }\n    @if (!hideSaveButton) {\n    <div class=\"form-row\">\n      <button mat-raised-button color=\"primary\" type=\"submit\" [disabled]=\"!form.valid\">Save</button>\n    </div>\n    }\n  </form>\n  } @else {\n  <div class=\"loading\">Loading...</div>\n  }\n\n  @if(item && !hideRelationships){\n  <div class=\"relationship-holder\">\n    <snteam-record-relationships [model]=\"mdl\" [id]=\"id\" [item]=\"item\" [amplifyOutputs]=\"outputs\"></snteam-record-relationships>\n  </div>\n  }\n</div>", styles: [".dynamic-form-holder{padding:20px;width:100%;display:flex;justify-content:space-between;gap:20px}form{width:100%;flex-basis:40%}.relationship-holder{flex-basis:40%}.full-width{width:100%}.form-row,.group-row{margin-top:20px}.loading{padding:20px;text-align:center;color:#666}\n"] }]
-        }], ctorParameters: () => [{ type: QuestionControlService }, { type: AmplifyFormBuilderService }, { type: i3$1.Location }, { type: i4$2.ActivatedRoute }], propDecorators: { model: [{
+        }], ctorParameters: () => [{ type: QuestionControlService }, { type: AmplifyFormBuilderService }, { type: i3$1.Location }, { type: i4$1.ActivatedRoute }], propDecorators: { model: [{
                 type: Input
             }], itemId: [{
                 type: Input
@@ -2194,7 +5125,7 @@ class ListViewComponent {
         this.listItems();
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: ListViewComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "20.3.15", type: ListViewComponent, isStandalone: true, selector: "snteam-list-view", inputs: { modelName: "modelName", customItemTemplate: "customItemTemplate", hideNewButton: "hideNewButton", title: "title", useRouter: "useRouter", showRowActions: "showRowActions", showDeleteAction: "showDeleteAction", customRowActions: "customRowActions" }, outputs: { itemClick: "itemClick", newClick: "newClick", itemsLoaded: "itemsLoaded", itemDeleted: "itemDeleted" }, ngImport: i0, template: "<div class=\"list-view-container\">\n  <div class=\"header\">\n    <h2>{{ title || modelName }}</h2>\n    @if (!hideNewButton) {\n    <button mat-raised-button color=\"primary\" (click)=\"onNewClick()\">\n      <mat-icon>add</mat-icon>\n      New {{ modelName }}\n    </button>\n    }\n  </div>\n\n  @if (loading) {\n  <div class=\"loading\">Loading {{ modelName }}...</div>\n  }\n\n  @if (error) {\n  <div class=\"error\">\n    {{ error }}\n    <button mat-button (click)=\"refresh()\">Retry</button>\n  </div>\n  }\n\n  @if (!loading && !error && itemsArr.length === 0) {\n  <div class=\"empty-state\">\n    <p>No {{ modelName }} found</p>\n    @if (!hideNewButton) {\n    <button mat-raised-button color=\"primary\" (click)=\"onNewClick()\">\n      Create First {{ modelName }}\n    </button>\n    }\n  </div>\n  }\n\n  @if (!loading && !error && itemsArr.length > 0) {\n  <mat-list class=\"items-list\">\n    @for (item of itemsArr; track item.id) {\n    <mat-list-item (click)=\"onItemClick(item, $event)\" class=\"clickable-item\">\n      @if (customItemTemplate) {\n      <ng-container [ngTemplateOutlet]=\"customItemTemplate\" [ngTemplateOutletContext]=\"{ $implicit: item }\"></ng-container>\n      } @else {\n      <div class=\"item-content\">\n        <div class=\"item-text\">\n          <span matListItemTitle>{{ getDisplayText(item) }}</span>\n          <span matListItemLine>{{ item.description || (item.createdAt | date) }}</span>\n        </div>\n        @if (showRowActions || showDeleteAction || customRowActions.length > 0) {\n        <div class=\"row-actions\">\n          @if (showDeleteAction) {\n          <button mat-icon-button color=\"warn\" (click)=\"onDeleteItem(item, $event)\" \n                  matTooltip=\"Delete\" class=\"action-button\">\n            <mat-icon>delete</mat-icon>\n          </button>\n          }\n          @for (action of customRowActions; track action.label) {\n          <button mat-icon-button [color]=\"action.color || 'primary'\" \n                  (click)=\"onCustomAction(action, item, $event)\"\n                  [matTooltip]=\"action.label\" class=\"action-button\">\n            <mat-icon>{{ action.icon }}</mat-icon>\n          </button>\n          }\n        </div>\n        }\n      </div>\n      }\n    </mat-list-item>\n    }\n  </mat-list>\n  }\n</div>", styles: [".list-view-container{padding:20px;width:100%}.header{display:flex;justify-content:space-between;align-items:center;margin-bottom:20px}.header h2{margin:0;color:#333}.loading,.error,.empty-state{padding:40px 20px;text-align:center;color:#666}.error{color:#d32f2f}.empty-state p{margin-bottom:20px;font-size:16px}.items-list{border:1px solid #e0e0e0;border-radius:4px}.clickable-item{cursor:pointer;transition:background-color .2s}.clickable-item:hover{background-color:#f5f5f5}.clickable-item:not(:last-child){border-bottom:1px solid #e0e0e0}.item-content{display:flex;justify-content:space-between;align-items:center;width:100%;padding:8px 0}.item-text{flex:1;display:flex;flex-direction:column}.row-actions{display:flex;gap:4px;margin-left:16px}.action-button{width:32px;height:32px;line-height:32px}.action-button mat-icon{font-size:18px;width:18px;height:18px}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i3$1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "ngmodule", type: MatListModule }, { kind: "component", type: i5$1.MatList, selector: "mat-list", exportAs: ["matList"] }, { kind: "component", type: i5$1.MatListItem, selector: "mat-list-item, a[mat-list-item], button[mat-list-item]", inputs: ["activated"], exportAs: ["matListItem"] }, { kind: "directive", type: i5$1.MatListItemLine, selector: "[matListItemLine]" }, { kind: "directive", type: i5$1.MatListItemTitle, selector: "[matListItemTitle]" }, { kind: "ngmodule", type: MatButtonModule }, { kind: "component", type: i3$3.MatButton, selector: "    button[matButton], a[matButton], button[mat-button], button[mat-raised-button],    button[mat-flat-button], button[mat-stroked-button], a[mat-button], a[mat-raised-button],    a[mat-flat-button], a[mat-stroked-button]  ", inputs: ["matButton"], exportAs: ["matButton", "matAnchor"] }, { kind: "component", type: i3$3.MatIconButton, selector: "button[mat-icon-button], a[mat-icon-button], button[matIconButton], a[matIconButton]", exportAs: ["matButton", "matAnchor"] }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i4$1.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "ngmodule", type: MatSnackBarModule }, { kind: "ngmodule", type: MatTooltipModule }, { kind: "directive", type: i5$2.MatTooltip, selector: "[matTooltip]", inputs: ["matTooltipPosition", "matTooltipPositionAtOrigin", "matTooltipDisabled", "matTooltipShowDelay", "matTooltipHideDelay", "matTooltipTouchGestures", "matTooltip", "matTooltipClass"], exportAs: ["matTooltip"] }, { kind: "pipe", type: i3$1.DatePipe, name: "date" }] });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "20.3.15", type: ListViewComponent, isStandalone: true, selector: "snteam-list-view", inputs: { modelName: "modelName", customItemTemplate: "customItemTemplate", hideNewButton: "hideNewButton", title: "title", useRouter: "useRouter", showRowActions: "showRowActions", showDeleteAction: "showDeleteAction", customRowActions: "customRowActions" }, outputs: { itemClick: "itemClick", newClick: "newClick", itemsLoaded: "itemsLoaded", itemDeleted: "itemDeleted" }, ngImport: i0, template: "<div class=\"list-view-container\">\n  <div class=\"header\">\n    <h2>{{ title || modelName }}</h2>\n    @if (!hideNewButton) {\n    <button mat-raised-button color=\"primary\" (click)=\"onNewClick()\">\n      <mat-icon>add</mat-icon>\n      New {{ modelName }}\n    </button>\n    }\n  </div>\n\n  @if (loading) {\n  <div class=\"loading\">Loading {{ modelName }}...</div>\n  }\n\n  @if (error) {\n  <div class=\"error\">\n    {{ error }}\n    <button mat-button (click)=\"refresh()\">Retry</button>\n  </div>\n  }\n\n  @if (!loading && !error && itemsArr.length === 0) {\n  <div class=\"empty-state\">\n    <p>No {{ modelName }} found</p>\n    @if (!hideNewButton) {\n    <button mat-raised-button color=\"primary\" (click)=\"onNewClick()\">\n      Create First {{ modelName }}\n    </button>\n    }\n  </div>\n  }\n\n  @if (!loading && !error && itemsArr.length > 0) {\n  <mat-list class=\"items-list\">\n    @for (item of itemsArr; track item.id) {\n    <mat-list-item (click)=\"onItemClick(item, $event)\" class=\"clickable-item\">\n      @if (customItemTemplate) {\n      <ng-container [ngTemplateOutlet]=\"customItemTemplate\" [ngTemplateOutletContext]=\"{ $implicit: item }\"></ng-container>\n      } @else {\n      <div class=\"item-content\">\n        <div class=\"item-text\">\n          <span matListItemTitle>{{ getDisplayText(item) }}</span>\n          <span matListItemLine>{{ item.description || (item.createdAt | date) }}</span>\n        </div>\n        @if (showRowActions || showDeleteAction || customRowActions.length > 0) {\n        <div class=\"row-actions\">\n          @if (showDeleteAction) {\n          <button mat-icon-button color=\"warn\" (click)=\"onDeleteItem(item, $event)\" \n                  matTooltip=\"Delete\" class=\"action-button\">\n            <mat-icon>delete</mat-icon>\n          </button>\n          }\n          @for (action of customRowActions; track action.label) {\n          <button mat-icon-button [color]=\"action.color || 'primary'\" \n                  (click)=\"onCustomAction(action, item, $event)\"\n                  [matTooltip]=\"action.label\" class=\"action-button\">\n            <mat-icon>{{ action.icon }}</mat-icon>\n          </button>\n          }\n        </div>\n        }\n      </div>\n      }\n    </mat-list-item>\n    }\n  </mat-list>\n  }\n</div>", styles: [".list-view-container{padding:20px;width:100%}.header{display:flex;justify-content:space-between;align-items:center;margin-bottom:20px}.header h2{margin:0;color:#333}.loading,.error,.empty-state{padding:40px 20px;text-align:center;color:#666}.error{color:#d32f2f}.empty-state p{margin-bottom:20px;font-size:16px}.items-list{border:1px solid #e0e0e0;border-radius:4px}.clickable-item{cursor:pointer;transition:background-color .2s}.clickable-item:hover{background-color:#f5f5f5}.clickable-item:not(:last-child){border-bottom:1px solid #e0e0e0}.item-content{display:flex;justify-content:space-between;align-items:center;width:100%;padding:8px 0}.item-text{flex:1;display:flex;flex-direction:column}.row-actions{display:flex;gap:4px;margin-left:16px}.action-button{width:32px;height:32px;line-height:32px}.action-button mat-icon{font-size:18px;width:18px;height:18px}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i3$1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "ngmodule", type: MatListModule }, { kind: "component", type: i6$1.MatList, selector: "mat-list", exportAs: ["matList"] }, { kind: "component", type: i6$1.MatListItem, selector: "mat-list-item, a[mat-list-item], button[mat-list-item]", inputs: ["activated"], exportAs: ["matListItem"] }, { kind: "directive", type: i6$1.MatListItemLine, selector: "[matListItemLine]" }, { kind: "directive", type: i6$1.MatListItemTitle, selector: "[matListItemTitle]" }, { kind: "ngmodule", type: MatButtonModule }, { kind: "component", type: i3$3.MatButton, selector: "    button[matButton], a[matButton], button[mat-button], button[mat-raised-button],    button[mat-flat-button], button[mat-stroked-button], a[mat-button], a[mat-raised-button],    a[mat-flat-button], a[mat-stroked-button]  ", inputs: ["matButton"], exportAs: ["matButton", "matAnchor"] }, { kind: "component", type: i3$3.MatIconButton, selector: "button[mat-icon-button], a[mat-icon-button], button[matIconButton], a[matIconButton]", exportAs: ["matButton", "matAnchor"] }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i5$1.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "ngmodule", type: MatSnackBarModule }, { kind: "ngmodule", type: MatTooltipModule }, { kind: "directive", type: i5$2.MatTooltip, selector: "[matTooltip]", inputs: ["matTooltipPosition", "matTooltipPositionAtOrigin", "matTooltipDisabled", "matTooltipShowDelay", "matTooltipHideDelay", "matTooltipTouchGestures", "matTooltip", "matTooltipClass"], exportAs: ["matTooltip"] }, { kind: "pipe", type: i3$1.DatePipe, name: "date" }] });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: ListViewComponent, decorators: [{
             type: Component,
@@ -2528,7 +5459,7 @@ return fields;
         return 'text'; // Default fallback
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: ConfigurationsComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "20.3.15", type: ConfigurationsComponent, isStandalone: true, selector: "snteam-configurations", inputs: { amplifyOutputs: "amplifyOutputs" }, ngImport: i0, template: "<div class=\"configurations-container\">\n  <h2>System Configurations</h2>\n  \n  <mat-accordion multi=\"true\">\n    \n    <!-- Table Configs Section -->\n    <mat-expansion-panel>\n      <mat-expansion-panel-header>\n        <mat-panel-title>\n          <mat-icon>table_chart</mat-icon>\n          <span class=\"panel-title\">Table Configs</span>\n        </mat-panel-title>\n        <mat-panel-description>\n          Manage table configurations and settings\n        </mat-panel-description>\n      </mat-expansion-panel-header>\n      \n      <div class=\"panel-content\">\n        @if (hasTableConfig) {\n          <div class=\"section-actions\">\n            <button mat-raised-button color=\"accent\" (click)=\"populateDefaultTableConfigs()\" class=\"populate-button\">\n              <mat-icon>auto_fix_high</mat-icon>\n              Populate Default Table Configs\n            </button>\n            <button mat-raised-button color=\"warn\" (click)=\"deleteTableConfigs()\" class=\"delete-button\">\n              <mat-icon>delete</mat-icon>\n              Delete All Table Configs\n            </button>\n          </div>\n          <snteam-list-view \n            [modelName]=\"'TableConfig'\"\n            [useRouter]=\"true\"\n            [showDeleteAction]=\"true\">\n          </snteam-list-view>\n        } @else {\n          <mat-card class=\"error-card\">\n            <mat-card-content>\n              <mat-icon class=\"error-icon\">error_outline</mat-icon>\n              <h3>TableConfig Model Not Found</h3>\n              <p>The TableConfig model is not available in your Amplify schema. Please add it to your data model to manage table configurations.</p>\n              <button mat-raised-button color=\"primary\" class=\"help-button\">\n                <mat-icon>help</mat-icon>\n                View Documentation\n              </button>\n            </mat-card-content>\n          </mat-card>\n        }\n      </div>\n    </mat-expansion-panel>\n\n    <!-- Form Views Section -->\n    <mat-expansion-panel>\n      <mat-expansion-panel-header>\n        <mat-panel-title>\n          <mat-icon>dynamic_form</mat-icon>\n          <span class=\"panel-title\">Form Views</span>\n        </mat-panel-title>\n        <mat-panel-description>\n          Configure custom form layouts and field selections\n        </mat-panel-description>\n      </mat-expansion-panel-header>\n      \n      <div class=\"panel-content\">\n        @if (hasFormView) {\n          <div class=\"section-actions\">\n            <button mat-raised-button color=\"warn\" (click)=\"deleteFormViews()\" class=\"delete-button\">\n              <mat-icon>delete</mat-icon>\n              Delete All Form Views\n            </button>\n          </div>\n          <snteam-list-view \n            [modelName]=\"'FormView'\"\n            [useRouter]=\"true\"\n            [showDeleteAction]=\"true\">\n          </snteam-list-view>\n        } @else {\n          <mat-card class=\"error-card\">\n            <mat-card-content>\n              <mat-icon class=\"error-icon\">error_outline</mat-icon>\n              <h3>FormView Model Not Found</h3>\n              <p>The FormView model is not available in your Amplify schema. Please add it to your data model to create custom form configurations.</p>\n              <button mat-raised-button color=\"primary\" class=\"help-button\">\n                <mat-icon>help</mat-icon>\n                View Documentation\n              </button>\n            </mat-card-content>\n          </mat-card>\n        }\n      </div>\n    </mat-expansion-panel>\n\n    <!-- List Views Section -->\n    <mat-expansion-panel>\n      <mat-expansion-panel-header>\n        <mat-panel-title>\n          <mat-icon>view_list</mat-icon>\n          <span class=\"panel-title\">List Views</span>\n        </mat-panel-title>\n        <mat-panel-description>\n          Customize list displays and column configurations\n        </mat-panel-description>\n      </mat-expansion-panel-header>\n      \n      <div class=\"panel-content\">\n        @if (hasListView) {\n          <div class=\"section-actions\">\n            <button mat-raised-button color=\"warn\" (click)=\"deleteListViews()\" class=\"delete-button\">\n              <mat-icon>delete</mat-icon>\n              Delete All List Views\n            </button>\n          </div>\n          <snteam-list-view \n            [modelName]=\"'ListView'\"\n            [useRouter]=\"true\"\n            [showDeleteAction]=\"true\">\n          </snteam-list-view>\n        } @else {\n          <mat-card class=\"error-card\">\n            <mat-card-content>\n              <mat-icon class=\"error-icon\">error_outline</mat-icon>\n              <h3>ListView Model Not Found</h3>\n              <p>The ListView model is not available in your Amplify schema. Please add it to your data model to create custom list view configurations.</p>\n              <button mat-raised-button color=\"primary\" class=\"help-button\">\n                <mat-icon>help</mat-icon>\n                View Documentation\n              </button>\n            </mat-card-content>\n          </mat-card>\n        }\n      </div>\n    </mat-expansion-panel>\n\n    <!-- Field Configs Section -->\n    <mat-expansion-panel>\n      <mat-expansion-panel-header>\n        <mat-panel-title>\n          <mat-icon>settings</mat-icon>\n          <span class=\"panel-title\">Field Configs</span>\n        </mat-panel-title>\n        <mat-panel-description>\n          Configure field behavior, validation, and choices\n        </mat-panel-description>\n      </mat-expansion-panel-header>\n      \n      <div class=\"panel-content\">\n        @if (hasFieldConfig) {\n          <div class=\"section-actions\">\n            <button mat-raised-button color=\"accent\" (click)=\"populateDefaultFieldConfigs()\" class=\"populate-button\">\n              <mat-icon>auto_fix_high</mat-icon>\n              Populate Default Field Configs\n            </button>\n            <button mat-raised-button color=\"warn\" (click)=\"deleteFieldConfigs()\" class=\"delete-button\">\n              <mat-icon>delete</mat-icon>\n              Delete All Field Configs\n            </button>\n          </div>\n          <snteam-list-view \n            [modelName]=\"'FieldConfig'\"\n            [useRouter]=\"true\"\n            [showDeleteAction]=\"true\">\n          </snteam-list-view>\n        } @else {\n          <mat-card class=\"error-card\">\n            <mat-card-content>\n              <mat-icon class=\"error-icon\">error_outline</mat-icon>\n              <h3>FieldConfig Model Not Found</h3>\n              <p>The FieldConfig model is not available in your Amplify schema. Please add it to your data model to configure field behavior and validation.</p>\n              <button mat-raised-button color=\"primary\" class=\"help-button\">\n                <mat-icon>help</mat-icon>\n                View Documentation\n              </button>\n            </mat-card-content>\n          </mat-card>\n        }\n      </div>\n    </mat-expansion-panel>\n\n  </mat-accordion>\n</div>", styles: [".configurations-container{padding:20px;max-width:1200px;margin:0 auto}.configurations-container h2{margin-bottom:24px;color:#333;font-weight:500}.mat-expansion-panel{margin-bottom:16px;border-radius:8px;box-shadow:0 2px 4px #0000001a}.mat-expansion-panel-header{padding:16px 24px}.panel-title{margin-left:12px;font-weight:500;font-size:16px}.mat-panel-description{color:#666;font-size:14px}.panel-content{padding:16px 24px 24px;background-color:#fafafa}.error-card{text-align:center;padding:24px;background-color:#fff;border:2px dashed #ddd;border-radius:8px}.error-card mat-card-content{padding:0}.error-icon{font-size:48px;width:48px;height:48px;color:#ff9800;margin-bottom:16px}.error-card h3{margin:0 0 12px;color:#333;font-weight:500}.error-card p{color:#666;line-height:1.5;max-width:500px;margin:0 auto 20px}.help-button{margin-top:8px}.help-button mat-icon{margin-right:8px}.section-actions{margin-bottom:16px;padding-bottom:16px;border-bottom:1px solid #e0e0e0;display:flex;gap:12px;flex-wrap:wrap}.generate-button{background-color:#2196f3;color:#fff}.generate-button mat-icon{margin-right:8px}.delete-button{background-color:#f44336;color:#fff}.delete-button mat-icon{margin-right:8px}.populate-button mat-icon{margin-right:8px}@media (max-width: 768px){.configurations-container{padding:16px}.panel-content{padding:12px 16px 16px}.error-card{padding:16px}.error-icon{font-size:36px;width:36px;height:36px}}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: MatExpansionModule }, { kind: "directive", type: i1$1.MatAccordion, selector: "mat-accordion", inputs: ["hideToggle", "displayMode", "togglePosition"], exportAs: ["matAccordion"] }, { kind: "component", type: i1$1.MatExpansionPanel, selector: "mat-expansion-panel", inputs: ["hideToggle", "togglePosition"], outputs: ["afterExpand", "afterCollapse"], exportAs: ["matExpansionPanel"] }, { kind: "component", type: i1$1.MatExpansionPanelHeader, selector: "mat-expansion-panel-header", inputs: ["expandedHeight", "collapsedHeight", "tabIndex"] }, { kind: "directive", type: i1$1.MatExpansionPanelTitle, selector: "mat-panel-title" }, { kind: "directive", type: i1$1.MatExpansionPanelDescription, selector: "mat-panel-description" }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i4$1.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "ngmodule", type: MatCardModule }, { kind: "component", type: i3$4.MatCard, selector: "mat-card", inputs: ["appearance"], exportAs: ["matCard"] }, { kind: "directive", type: i3$4.MatCardContent, selector: "mat-card-content" }, { kind: "ngmodule", type: MatButtonModule }, { kind: "component", type: i3$3.MatButton, selector: "    button[matButton], a[matButton], button[mat-button], button[mat-raised-button],    button[mat-flat-button], button[mat-stroked-button], a[mat-button], a[mat-raised-button],    a[mat-flat-button], a[mat-stroked-button]  ", inputs: ["matButton"], exportAs: ["matButton", "matAnchor"] }, { kind: "ngmodule", type: MatSnackBarModule }, { kind: "component", type: ListViewComponent, selector: "snteam-list-view", inputs: ["modelName", "customItemTemplate", "hideNewButton", "title", "useRouter", "showRowActions", "showDeleteAction", "customRowActions"], outputs: ["itemClick", "newClick", "itemsLoaded", "itemDeleted"] }] });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "20.3.15", type: ConfigurationsComponent, isStandalone: true, selector: "snteam-configurations", inputs: { amplifyOutputs: "amplifyOutputs" }, ngImport: i0, template: "<div class=\"configurations-container\">\n  <h2>System Configurations</h2>\n  \n  <mat-accordion multi=\"true\">\n    \n    <!-- Table Configs Section -->\n    <mat-expansion-panel>\n      <mat-expansion-panel-header>\n        <mat-panel-title>\n          <mat-icon>table_chart</mat-icon>\n          <span class=\"panel-title\">Table Configs</span>\n        </mat-panel-title>\n        <mat-panel-description>\n          Manage table configurations and settings\n        </mat-panel-description>\n      </mat-expansion-panel-header>\n      \n      <div class=\"panel-content\">\n        @if (hasTableConfig) {\n          <div class=\"section-actions\">\n            <button mat-raised-button color=\"accent\" (click)=\"populateDefaultTableConfigs()\" class=\"populate-button\">\n              <mat-icon>auto_fix_high</mat-icon>\n              Populate Default Table Configs\n            </button>\n            <button mat-raised-button color=\"warn\" (click)=\"deleteTableConfigs()\" class=\"delete-button\">\n              <mat-icon>delete</mat-icon>\n              Delete All Table Configs\n            </button>\n          </div>\n          <snteam-list-view \n            [modelName]=\"'TableConfig'\"\n            [useRouter]=\"true\"\n            [showDeleteAction]=\"true\">\n          </snteam-list-view>\n        } @else {\n          <mat-card class=\"error-card\">\n            <mat-card-content>\n              <mat-icon class=\"error-icon\">error_outline</mat-icon>\n              <h3>TableConfig Model Not Found</h3>\n              <p>The TableConfig model is not available in your Amplify schema. Please add it to your data model to manage table configurations.</p>\n              <button mat-raised-button color=\"primary\" class=\"help-button\">\n                <mat-icon>help</mat-icon>\n                View Documentation\n              </button>\n            </mat-card-content>\n          </mat-card>\n        }\n      </div>\n    </mat-expansion-panel>\n\n    <!-- Form Views Section -->\n    <mat-expansion-panel>\n      <mat-expansion-panel-header>\n        <mat-panel-title>\n          <mat-icon>dynamic_form</mat-icon>\n          <span class=\"panel-title\">Form Views</span>\n        </mat-panel-title>\n        <mat-panel-description>\n          Configure custom form layouts and field selections\n        </mat-panel-description>\n      </mat-expansion-panel-header>\n      \n      <div class=\"panel-content\">\n        @if (hasFormView) {\n          <div class=\"section-actions\">\n            <button mat-raised-button color=\"warn\" (click)=\"deleteFormViews()\" class=\"delete-button\">\n              <mat-icon>delete</mat-icon>\n              Delete All Form Views\n            </button>\n          </div>\n          <snteam-list-view \n            [modelName]=\"'FormView'\"\n            [useRouter]=\"true\"\n            [showDeleteAction]=\"true\">\n          </snteam-list-view>\n        } @else {\n          <mat-card class=\"error-card\">\n            <mat-card-content>\n              <mat-icon class=\"error-icon\">error_outline</mat-icon>\n              <h3>FormView Model Not Found</h3>\n              <p>The FormView model is not available in your Amplify schema. Please add it to your data model to create custom form configurations.</p>\n              <button mat-raised-button color=\"primary\" class=\"help-button\">\n                <mat-icon>help</mat-icon>\n                View Documentation\n              </button>\n            </mat-card-content>\n          </mat-card>\n        }\n      </div>\n    </mat-expansion-panel>\n\n    <!-- List Views Section -->\n    <mat-expansion-panel>\n      <mat-expansion-panel-header>\n        <mat-panel-title>\n          <mat-icon>view_list</mat-icon>\n          <span class=\"panel-title\">List Views</span>\n        </mat-panel-title>\n        <mat-panel-description>\n          Customize list displays and column configurations\n        </mat-panel-description>\n      </mat-expansion-panel-header>\n      \n      <div class=\"panel-content\">\n        @if (hasListView) {\n          <div class=\"section-actions\">\n            <button mat-raised-button color=\"warn\" (click)=\"deleteListViews()\" class=\"delete-button\">\n              <mat-icon>delete</mat-icon>\n              Delete All List Views\n            </button>\n          </div>\n          <snteam-list-view \n            [modelName]=\"'ListView'\"\n            [useRouter]=\"true\"\n            [showDeleteAction]=\"true\">\n          </snteam-list-view>\n        } @else {\n          <mat-card class=\"error-card\">\n            <mat-card-content>\n              <mat-icon class=\"error-icon\">error_outline</mat-icon>\n              <h3>ListView Model Not Found</h3>\n              <p>The ListView model is not available in your Amplify schema. Please add it to your data model to create custom list view configurations.</p>\n              <button mat-raised-button color=\"primary\" class=\"help-button\">\n                <mat-icon>help</mat-icon>\n                View Documentation\n              </button>\n            </mat-card-content>\n          </mat-card>\n        }\n      </div>\n    </mat-expansion-panel>\n\n    <!-- Field Configs Section -->\n    <mat-expansion-panel>\n      <mat-expansion-panel-header>\n        <mat-panel-title>\n          <mat-icon>settings</mat-icon>\n          <span class=\"panel-title\">Field Configs</span>\n        </mat-panel-title>\n        <mat-panel-description>\n          Configure field behavior, validation, and choices\n        </mat-panel-description>\n      </mat-expansion-panel-header>\n      \n      <div class=\"panel-content\">\n        @if (hasFieldConfig) {\n          <div class=\"section-actions\">\n            <button mat-raised-button color=\"accent\" (click)=\"populateDefaultFieldConfigs()\" class=\"populate-button\">\n              <mat-icon>auto_fix_high</mat-icon>\n              Populate Default Field Configs\n            </button>\n            <button mat-raised-button color=\"warn\" (click)=\"deleteFieldConfigs()\" class=\"delete-button\">\n              <mat-icon>delete</mat-icon>\n              Delete All Field Configs\n            </button>\n          </div>\n          <snteam-list-view \n            [modelName]=\"'FieldConfig'\"\n            [useRouter]=\"true\"\n            [showDeleteAction]=\"true\">\n          </snteam-list-view>\n        } @else {\n          <mat-card class=\"error-card\">\n            <mat-card-content>\n              <mat-icon class=\"error-icon\">error_outline</mat-icon>\n              <h3>FieldConfig Model Not Found</h3>\n              <p>The FieldConfig model is not available in your Amplify schema. Please add it to your data model to configure field behavior and validation.</p>\n              <button mat-raised-button color=\"primary\" class=\"help-button\">\n                <mat-icon>help</mat-icon>\n                View Documentation\n              </button>\n            </mat-card-content>\n          </mat-card>\n        }\n      </div>\n    </mat-expansion-panel>\n\n  </mat-accordion>\n</div>", styles: [".configurations-container{padding:20px;max-width:1200px;margin:0 auto}.configurations-container h2{margin-bottom:24px;color:#333;font-weight:500}.mat-expansion-panel{margin-bottom:16px;border-radius:8px;box-shadow:0 2px 4px #0000001a}.mat-expansion-panel-header{padding:16px 24px}.panel-title{margin-left:12px;font-weight:500;font-size:16px}.mat-panel-description{color:#666;font-size:14px}.panel-content{padding:16px 24px 24px;background-color:#fafafa}.error-card{text-align:center;padding:24px;background-color:#fff;border:2px dashed #ddd;border-radius:8px}.error-card mat-card-content{padding:0}.error-icon{font-size:48px;width:48px;height:48px;color:#ff9800;margin-bottom:16px}.error-card h3{margin:0 0 12px;color:#333;font-weight:500}.error-card p{color:#666;line-height:1.5;max-width:500px;margin:0 auto 20px}.help-button{margin-top:8px}.help-button mat-icon{margin-right:8px}.section-actions{margin-bottom:16px;padding-bottom:16px;border-bottom:1px solid #e0e0e0;display:flex;gap:12px;flex-wrap:wrap}.generate-button{background-color:#2196f3;color:#fff}.generate-button mat-icon{margin-right:8px}.delete-button{background-color:#f44336;color:#fff}.delete-button mat-icon{margin-right:8px}.populate-button mat-icon{margin-right:8px}@media (max-width: 768px){.configurations-container{padding:16px}.panel-content{padding:12px 16px 16px}.error-card{padding:16px}.error-icon{font-size:36px;width:36px;height:36px}}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: MatExpansionModule }, { kind: "directive", type: i1$1.MatAccordion, selector: "mat-accordion", inputs: ["hideToggle", "displayMode", "togglePosition"], exportAs: ["matAccordion"] }, { kind: "component", type: i1$1.MatExpansionPanel, selector: "mat-expansion-panel", inputs: ["hideToggle", "togglePosition"], outputs: ["afterExpand", "afterCollapse"], exportAs: ["matExpansionPanel"] }, { kind: "component", type: i1$1.MatExpansionPanelHeader, selector: "mat-expansion-panel-header", inputs: ["expandedHeight", "collapsedHeight", "tabIndex"] }, { kind: "directive", type: i1$1.MatExpansionPanelTitle, selector: "mat-panel-title" }, { kind: "directive", type: i1$1.MatExpansionPanelDescription, selector: "mat-panel-description" }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i5$1.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "ngmodule", type: MatCardModule }, { kind: "component", type: i3$5.MatCard, selector: "mat-card", inputs: ["appearance"], exportAs: ["matCard"] }, { kind: "directive", type: i3$5.MatCardContent, selector: "mat-card-content" }, { kind: "ngmodule", type: MatButtonModule }, { kind: "component", type: i3$3.MatButton, selector: "    button[matButton], a[matButton], button[mat-button], button[mat-raised-button],    button[mat-flat-button], button[mat-stroked-button], a[mat-button], a[mat-raised-button],    a[mat-flat-button], a[mat-stroked-button]  ", inputs: ["matButton"], exportAs: ["matButton", "matAnchor"] }, { kind: "ngmodule", type: MatSnackBarModule }, { kind: "component", type: ListViewComponent, selector: "snteam-list-view", inputs: ["modelName", "customItemTemplate", "hideNewButton", "title", "useRouter", "showRowActions", "showDeleteAction", "customRowActions"], outputs: ["itemClick", "newClick", "itemsLoaded", "itemDeleted"] }] });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: ConfigurationsComponent, decorators: [{
             type: Component,
@@ -2554,5 +5485,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImpo
  * Generated bundle index. Do not edit.
  */
 
-export { AddRelationshipDialogComponent, AmplifyAngularCore, AmplifyFormBuilderService, AmplifyModelService, AsyncDropdownQuestion, ConfigurationsComponent, DatePickerQuestion, DateTimePickerQuestion, DropdownQuestion, DynamicFormComponent, DynamicFormGroupComponent, DynamicFormQuestionComponent, DynamicNestedFormQuestionComponent, DynamicRelationshipBuilderComponent, EmailQuestion, FormGroupQuestion, ListViewComponent, MyErrorStateMatcher, NumberQuestion, PhoneQuestion, QuestionBase, QuestionControlService, RecordRelationshipsComponent, SliderQuestion, TextboxQuestion, TimePickerQuestion, ValToTitlePipe, phoneNumberValidator };
+export { AddRelationshipDialogComponent, AmplifyAngularCore, AmplifyFormBuilderService, AmplifyModelService, AsyncDropdownQuestion, ConfigurationAnalyzerService, ConfigurationsComponent, DatePickerQuestion, DateTimePickerQuestion, DropdownQuestion, DynamicFormComponent, DynamicFormGroupComponent, DynamicFormQuestionComponent, DynamicNestedFormQuestionComponent, DynamicRelationshipBuilderComponent, EmailQuestion, FieldClassification, FormGroupQuestion, ListViewComponent, MyErrorStateMatcher, NumberQuestion, PhoneQuestion, QuestionBase, QuestionControlService, RecordRelationshipsComponent, SchemaIntrospectorService, SelectionSetErrorType, SelectionSetGeneratorService, SelectionSetPattern, SliderQuestion, TextboxQuestion, TimePickerQuestion, ValToTitlePipe, phoneNumberValidator };
 //# sourceMappingURL=snteam-amplify-angular-core.mjs.map