@snteam/amplify-angular-core 1.0.35 → 1.0.37

package/index.d.ts

@@ -7,6 +7,767 @@ import { Observable } from 'rxjs';
 import { ErrorStateMatcher } from '@angular/material/core';
 import { MatDialog, MatDialogRef } from '@angular/material/dialog';
 
+/**
+ * Interface for generating dynamic GraphQL selection sets for Amplify relationships
+ */
+interface SelectionSetGenerator {
+    /**
+     * Generate a selection set for a given relationship configuration
+     * @param config The relationship configuration to analyze
+     * @returns Array of GraphQL field selectors
+     */
+    generateSelectionSet(config: RelationshipConfiguration): string[];
+    /**
+     * Generate a fallback selection set when primary generation fails
+     * @param fieldName The field name to create a basic selection set for
+     * @returns Array of basic GraphQL field selectors
+     */
+    generateFallbackSelectionSet(fieldName: string): string[];
+    /**
+     * Generate fallback selection set with progressive retry strategies
+     * @param fieldName The field name to create a selection set for
+     * @param previousErrors Array of previous error messages to skip failed strategies
+     * @returns Array of GraphQL field selectors using progressive fallback
+     */
+    generateFallbackSelectionSetWithRetry(fieldName: string, previousErrors?: string[]): string[];
+    /**
+     * Clear the internal cache of generated selection sets
+     */
+    clearCache(): void;
+}
+/**
+ * Configuration object describing a relationship between Amplify models
+ */
+interface RelationshipConfiguration {
+    /** The name of the relationship/junction model (e.g., "FormViewField") */
+    relationshipModelName: string;
+    /** The name of the base/parent model (e.g., "FormView") */
+    baseModelName: string;
+    /** The field name used to access the related model (e.g., "formView") */
+    fieldName: string;
+    /** The foreign key field name in the relationship model (e.g., "formViewId") */
+    associatedWith: string;
+}
+
+/**
+ * Interface for analyzing relationship configurations to extract field mappings
+ */
+interface ConfigurationAnalyzer {
+    /**
+     * Analyze a relationship configuration to extract field mappings and validate structure
+     * @param config The relationship configuration to analyze
+     * @returns Analysis result with extracted information and validation status
+     */
+    analyzeConfiguration(config: RelationshipConfiguration): AnalysisResult;
+    /**
+     * Extract the target model name from a relationship configuration
+     * @param config The relationship configuration to analyze
+     * @returns The name of the target model
+     */
+    extractTargetModelName(config: RelationshipConfiguration): string;
+    /**
+     * Determine appropriate field selectors for a target model
+     * @param targetModel The name of the target model
+     * @returns Array of field selector strings for common display properties
+     */
+    determineFieldSelectors(targetModel: string): string[];
+}
+/**
+ * Result of analyzing a relationship configuration
+ */
+interface AnalysisResult {
+    /** The name of the target model extracted from the configuration */
+    targetModelName: string;
+    /** Array of field selectors appropriate for the target model */
+    fieldSelectors: string[];
+    /** Whether the configuration analysis was successful */
+    isValid: boolean;
+    /** Array of error messages if analysis failed */
+    errors: string[];
+}
+
+/**
+ * Interface for introspecting Amplify schema data to validate and enhance selection sets
+ */
+interface SchemaIntrospector {
+    /**
+     * Get field information for a specific model from the schema
+     * @param modelName The name of the model to introspect
+     * @returns Array of field information for the model
+     */
+    getModelFields(modelName: string): ModelField[];
+    /**
+     * Validate that a specific field exists in a model
+     * @param modelName The name of the model to check
+     * @param fieldName The name of the field to validate
+     * @returns True if the field exists, false otherwise
+     */
+    validateFieldExists(modelName: string, fieldName: string): boolean;
+    /**
+     * Get common display fields for a model (e.g., name, title, label)
+     * @param modelName The name of the model to analyze
+     * @returns Array of field names suitable for display
+     */
+    getCommonDisplayFields(modelName: string): string[];
+    /**
+     * Check if schema introspection data is available
+     * @returns True if schema data is available, false otherwise
+     */
+    isSchemaAvailable(): boolean;
+}
+/**
+ * Information about a field in an Amplify model
+ */
+interface ModelField {
+    /** The name of the field */
+    name: string;
+    /** The type of the field (string, number, object, etc.) */
+    type: string;
+    /** Whether the field is required */
+    isRequired: boolean;
+    /** Whether the field represents a relationship to another model */
+    isRelationship: boolean;
+}
+
+/**
+ * Cache key for storing generated selection sets
+ */
+interface CacheKey {
+    /** The relationship model name */
+    relationshipModel: string;
+    /** The field name used to access the related model */
+    fieldName: string;
+    /** The target model name */
+    targetModel: string;
+    /** Optional schema version for cache invalidation */
+    schemaVersion?: string;
+}
+/**
+ * Cached selection set entry
+ */
+interface CachedSelectionSet {
+    /** The cache key used to store this entry */
+    key: CacheKey;
+    /** The generated selection set */
+    selectionSet: string[];
+    /** Timestamp when this entry was created */
+    createdAt: Date;
+    /** Number of times this entry has been accessed */
+    accessCount: number;
+}
+/**
+ * Selection set generation patterns
+ */
+declare enum SelectionSetPattern {
+    /** Basic relationship loading with id and common display fields */
+    BASIC = "basic",
+    /** Comprehensive field loading using wildcard selection */
+    COMPREHENSIVE = "comprehensive",
+    /** Selective field loading based on schema analysis */
+    SELECTIVE = "selective",
+    /** Minimal fallback pattern for error cases */
+    FALLBACK = "fallback"
+}
+/**
+ * Configuration for selection set generation
+ */
+interface SelectionSetConfig {
+    /** The pattern to use for generation */
+    pattern: SelectionSetPattern;
+    /** Maximum nesting depth for relationships */
+    maxDepth: number;
+    /** Maximum number of fields to include */
+    maxFields: number;
+    /** Whether to include schema validation */
+    validateWithSchema: boolean;
+    /** Custom field names to always include */
+    requiredFields: string[];
+    /** Complexity limits for selection set validation */
+    complexityLimits: ComplexityLimits;
+}
+/**
+ * Complexity limits for selection set validation
+ */
+interface ComplexityLimits {
+    /** Maximum nesting depth for relationships (default: 3) */
+    maxNestingDepth: number;
+    /** Maximum number of fields per selection set (default: 20) */
+    maxFieldCount: number;
+    /** Maximum number of wildcard selections allowed (default: 2) */
+    maxWildcardSelections: number;
+    /** Whether to detect and prevent circular references (default: true) */
+    preventCircularReferences: boolean;
+    /** Maximum length for individual field selectors (default: 100) */
+    maxSelectorLength: number;
+}
+/**
+ * Result of complexity validation
+ */
+interface ComplexityValidationResult {
+    /** Whether the selection set passes complexity validation */
+    isValid: boolean;
+    /** List of validation errors if any */
+    errors: string[];
+    /** List of validation warnings */
+    warnings: string[];
+    /** Calculated complexity score */
+    complexityScore: number;
+    /** Detected circular references if any */
+    circularReferences: string[];
+}
+/**
+ * Display optimization configuration
+ */
+interface DisplayOptimizationConfig {
+    /** Whether to enable display optimization */
+    enabled: boolean;
+    /** Fields that are commonly used for display */
+    commonDisplayFields: string[];
+    /** Fields that should be excluded from display optimization */
+    excludeFromOptimization: string[];
+    /** Whether to prioritize display fields over other fields */
+    prioritizeDisplayFields: boolean;
+    /** Maximum number of non-display fields to include */
+    maxNonDisplayFields: number;
+}
+/**
+ * Field classification for display optimization
+ */
+declare enum FieldClassification {
+    /** Essential fields that must always be included */
+    ESSENTIAL = "essential",
+    /** Display fields commonly shown in UI */
+    DISPLAY = "display",
+    /** Metadata fields that provide additional context */
+    METADATA = "metadata",
+    /** Relationship fields that link to other models */
+    RELATIONSHIP = "relationship",
+    /** System fields used internally */
+    SYSTEM = "system",
+    /** Unknown or unclassified fields */
+    UNKNOWN = "unknown"
+}
+/**
+ * Field analysis result for optimization
+ */
+interface FieldAnalysis {
+    /** The field selector */
+    selector: string;
+    /** Classification of the field */
+    classification: FieldClassification;
+    /** Priority score for inclusion (higher = more important) */
+    priority: number;
+    /** Estimated cost of including this field */
+    cost: number;
+    /** Whether this field is likely to be displayed in UI */
+    isDisplayRelevant: boolean;
+}
+
+/**
+ * Types of errors that can occur during selection set generation
+ */
+declare enum SelectionSetErrorType {
+    /** Configuration is invalid or incomplete */
+    INVALID_CONFIGURATION = "invalid_configuration",
+    /** Target model not found in schema */
+    MODEL_NOT_FOUND = "model_not_found",
+    /** Field not found in target model */
+    FIELD_NOT_FOUND = "field_not_found",
+    /** Schema introspection data unavailable */
+    SCHEMA_UNAVAILABLE = "schema_unavailable",
+    /** Generated selection set exceeds complexity limits */
+    COMPLEXITY_EXCEEDED = "complexity_exceeded",
+    /** Circular reference detected in relationship chain */
+    CIRCULAR_REFERENCE = "circular_reference",
+    /** GraphQL query failed with generated selection set */
+    GRAPHQL_ERROR = "graphql_error"
+}
+/**
+ * Error information for selection set generation failures
+ */
+interface SelectionSetError {
+    /** The type of error that occurred */
+    type: SelectionSetErrorType;
+    /** Human-readable error message */
+    message: string;
+    /** The relationship configuration that caused the error */
+    configuration?: RelationshipConfiguration;
+    /** The selection set that was being generated (if any) */
+    selectionSet?: string[];
+    /** Additional context information */
+    context?: Record<string, any>;
+    /** Timestamp when the error occurred */
+    timestamp: Date;
+}
+/**
+ * Result of a selection set generation attempt
+ */
+interface SelectionSetResult {
+    /** Whether the generation was successful */
+    success: boolean;
+    /** The generated selection set (if successful) */
+    selectionSet?: string[];
+    /** Error information (if failed) */
+    error?: SelectionSetError;
+    /** Whether a fallback was used */
+    usedFallback: boolean;
+    /** The pattern that was used for generation */
+    patternUsed?: string;
+}
+
+/**
+ * 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.
+ */
+declare class ErrorHandlerService {
+    /**
+     * Maximum number of error logs to keep in memory
+     */
+    private readonly MAX_ERROR_LOGS;
+    /**
+     * In-memory error log storage for debugging
+     */
+    private errorLogs;
+    /**
+     * Error statistics for monitoring
+     */
+    private errorStats;
+    /**
+     * Log a selection set generation error with comprehensive context
+     */
+    logSelectionSetError(type: SelectionSetErrorType, message: string, config?: RelationshipConfiguration, selectionSet?: string[], additionalContext?: Record<string, any>): SelectionSetError;
+    /**
+     * Log a GraphQL query error with retry context
+     */
+    logGraphQLError(error: any, config: RelationshipConfiguration, selectionSet: string[], retryAttempt: number, previousErrors?: string[]): SelectionSetError;
+    /**
+     * Log a configuration analysis error
+     */
+    logConfigurationError(config: RelationshipConfiguration | null, errors: string[], additionalContext?: Record<string, any>): SelectionSetError;
+    /**
+     * Log a schema introspection error
+     */
+    logSchemaError(modelName: string, fieldName?: string, additionalContext?: Record<string, any>): SelectionSetError;
+    /**
+     * Log a complexity validation error
+     */
+    logComplexityError(selectionSet: string[], validationErrors: string[], config?: RelationshipConfiguration): SelectionSetError;
+    /**
+     * Log a circular reference error
+     */
+    logCircularReferenceError(circularPath: string, selectionSet: string[], config?: RelationshipConfiguration): SelectionSetError;
+    /**
+     * Log a successful error recovery
+     */
+    logSuccessfulRecovery(originalError: SelectionSetError, recoveryMethod: string, finalSelectionSet: string[]): void;
+    /**
+     * Log a failed error recovery attempt
+     */
+    logFailedRecovery(originalError: SelectionSetError, recoveryAttempts: string[], finalError: any): void;
+    /**
+     * Create a SelectionSetResult for a successful operation
+     */
+    createSuccessResult(selectionSet: string[], patternUsed?: string, usedFallback?: boolean): SelectionSetResult;
+    /**
+     * Create a SelectionSetResult for a failed operation
+     */
+    createErrorResult(error: SelectionSetError): SelectionSetResult;
+    /**
+     * Get error statistics for monitoring and debugging
+     */
+    getErrorStats(): {
+        totalErrors: number;
+        errorsByType: Record<string, number>;
+        lastError: SelectionSetError | null;
+        recoveryAttempts: number;
+        successfulRecoveries: number;
+        recoveryRate: number;
+        recentErrors: SelectionSetError[];
+    };
+    /**
+     * Get recent error logs for debugging
+     */
+    getRecentErrors(count?: number): SelectionSetError[];
+    /**
+     * Clear all error logs and reset statistics
+     */
+    clearErrorLogs(): void;
+    /**
+     * Check if the system is experiencing high error rates
+     */
+    isHighErrorRate(timeWindowMinutes?: number, threshold?: number): boolean;
+    /**
+     * Get error patterns for analysis
+     */
+    getErrorPatterns(): {
+        mostCommonErrorType: SelectionSetErrorType | null;
+        mostProblematicModel: string | null;
+        mostProblematicField: string | null;
+        errorTrends: Array<{
+            hour: string;
+            errorCount: number;
+        }>;
+    };
+    /**
+     * Add error to the log with size management
+     */
+    private addErrorLog;
+    /**
+     * Update error statistics
+     */
+    private updateErrorStats;
+    /**
+     * Calculate recovery rate percentage
+     */
+    private getRecoveryRate;
+    /**
+     * Log error to console with structured format
+     */
+    private logToConsole;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorHandlerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ErrorHandlerService>;
+}
+
+/**
+ * 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.
+ */
+declare class ConfigurationAnalyzerService implements ConfigurationAnalyzer {
+    private errorHandler;
+    /**
+     * Common display field names to look for in models
+     */
+    private readonly COMMON_DISPLAY_FIELDS;
+    constructor(errorHandler: ErrorHandlerService);
+    /**
+     * Analyze a relationship configuration to extract field mappings and validate structure
+     * Enhanced with comprehensive error handling and logging
+     */
+    analyzeConfiguration(config: RelationshipConfiguration): AnalysisResult;
+    /**
+     * 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: RelationshipConfiguration): string;
+    /**
+     * 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: string): string[];
+    /**
+     * Parse and validate nested relationship paths
+     *
+     * Handles complex relationship configurations like "formView.user.profile"
+     * and validates for circular references
+     */
+    parseNestedRelationshipPath(fieldName: string, maxDepth?: number): string[];
+    /**
+     * Generate field selectors for nested relationship paths
+     *
+     * Creates GraphQL selectors that can handle nested relationships
+     * like "formView.user.profile.name"
+     */
+    generateNestedFieldSelectors(fieldName: string, targetModel: string): string[];
+    /**
+     * Enhanced field selector determination that supports nested paths
+     */
+    determineFieldSelectorsEnhanced(targetModel: string, fieldName?: string): string[];
+    /**
+     * Convert a string to PascalCase (first letter uppercase, rest camelCase)
+     */
+    private toPascalCase;
+    /**
+     * Convert a string to camelCase (first letter lowercase)
+     */
+    private toCamelCase;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigurationAnalyzerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConfigurationAnalyzerService>;
+}
+
+/**
+ * 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.
+ */
+declare class SchemaIntrospectorService implements SchemaIntrospector {
+    private errorHandler;
+    private amplifyOutputs;
+    /**
+     * Common display field names that are typically used for showing model data
+     */
+    private readonly COMMON_DISPLAY_FIELDS;
+    /**
+     * System fields that are typically not used for display
+     */
+    private readonly SYSTEM_FIELDS;
+    constructor(errorHandler: ErrorHandlerService);
+    /**
+     * 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: any): void;
+    /**
+     * Get field information for a specific model from the schema
+     * Enhanced with comprehensive error handling and logging
+     */
+    getModelFields(modelName: string): ModelField[];
+    /**
+     * Validate that a specific field exists in a model
+     */
+    validateFieldExists(modelName: string, fieldName: string): boolean;
+    /**
+     * Get common display fields for a model (e.g., name, title, label)
+     */
+    getCommonDisplayFields(modelName: string): string[];
+    /**
+     * Check if schema introspection data is available
+     */
+    isSchemaAvailable(): boolean;
+    /**
+     * Get conservative display fields when schema data is unavailable
+     * This provides a safe fallback that works with most Amplify models
+     */
+    getConservativeDisplayFields(modelName: string): string[];
+    /**
+     * Get model fields with fallback behavior when schema is unavailable
+     */
+    getModelFieldsWithFallback(modelName: string): ModelField[];
+    /**
+     * Validate field existence with fallback behavior
+     * When schema is unavailable, assumes common fields exist
+     */
+    validateFieldExistsWithFallback(modelName: string, fieldName: string): boolean;
+    /**
+     * Get safe field selectors that work even when schema data is unavailable
+     * This method prioritizes reliability over completeness
+     */
+    getSafeFieldSelectors(modelName: string, fieldName: string): string[];
+    /**
+     * Get schema status information for debugging
+     */
+    getSchemaStatus(): {
+        isAvailable: boolean;
+        modelCount: number;
+        availableModels: string[];
+        lastError?: string;
+    };
+    /**
+     * Get all available model names from the schema
+     */
+    getAvailableModels(): string[];
+    /**
+     * Get detailed information about a specific model
+     */
+    getModelInfo(modelName: string): any;
+    /**
+     * Determine the simplified type of a field from Amplify schema data
+     */
+    private determineFieldType;
+    /**
+     * Check if a field represents a relationship to another model
+     */
+    private isRelationshipField;
+    /**
+     * Get relationship information for a field
+     */
+    getRelationshipInfo(modelName: string, fieldName: string): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SchemaIntrospectorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SchemaIntrospectorService>;
+}
+
+/**
+ * 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.
+ */
+declare class SelectionSetGeneratorService implements SelectionSetGenerator {
+    private configurationAnalyzer;
+    private schemaIntrospector;
+    private errorHandler;
+    /**
+     * Cache for generated selection sets to improve performance
+     */
+    private selectionSetCache;
+    /**
+     * Default configuration for selection set generation
+     */
+    private readonly DEFAULT_CONFIG;
+    /**
+     * Default display optimization configuration
+     */
+    private readonly DEFAULT_DISPLAY_CONFIG;
+    constructor(configurationAnalyzer: ConfigurationAnalyzerService, schemaIntrospector: SchemaIntrospectorService, errorHandler: ErrorHandlerService);
+    /**
+     * Generate a selection set for a given relationship configuration
+     * Enhanced with comprehensive error handling and logging
+     */
+    generateSelectionSet(config: RelationshipConfiguration): string[];
+    /**
+     * 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: string): string[];
+    /**
+     * Generate comprehensive fallback selection set using schema data
+     * This is the first fallback strategy when schema is available
+     */
+    private generateComprehensiveFallbackSelectionSet;
+    /**
+     * Generate selective fallback selection set using common field patterns
+     * This is the second fallback strategy when schema is unavailable
+     */
+    private generateSelectiveFallbackSelectionSet;
+    /**
+     * Generate minimal fallback selection set for critical error cases
+     * This is the last resort fallback strategy
+     */
+    private generateMinimalFallbackSelectionSet;
+    /**
+     * 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: string, previousErrors?: string[]): string[];
+    /**
+     * Handle generation errors by attempting fallback with comprehensive logging
+     */
+    private handleGenerationError;
+    /**
+     * Validate a selection set for basic correctness
+     */
+    private validateSelectionSet;
+    /**
+     * Clear the internal cache of generated selection sets
+     */
+    clearCache(): void;
+    /**
+     * Generate selection set from configuration analysis result
+     */
+    private generateSelectionSetFromAnalysis;
+    /**
+     * Generate selection set using schema introspection data
+     */
+    private generateSchemaAwareSelectionSet;
+    /**
+     * Generate selection set using configuration analysis only
+     */
+    private generateConfigurationBasedSelectionSet;
+    /**
+     * Apply display optimization to prioritize display-relevant fields
+     */
+    private applyDisplayOptimization;
+    /**
+     * Analyze a field selector for display optimization
+     */
+    private analyzeFieldForDisplay;
+    /**
+     * Check if a selector represents a relationship field
+     */
+    private isRelationshipField;
+    /**
+     * Check if a relationship field is likely to be displayed
+     */
+    private isDisplayRelevantRelationship;
+    /**
+     * Check if a selector represents a metadata field
+     */
+    private isMetadataField;
+    /**
+     * Check if a selector represents a system field
+     */
+    private isSystemField;
+    /**
+     * Apply complexity limits to prevent overly expensive GraphQL queries
+     * Enhanced with comprehensive error handling and logging
+     */
+    private applyComplexityLimits;
+    /**
+     * Validate selection set complexity against configured limits
+     */
+    private validateSelectionSetComplexity;
+    /**
+     * Detect circular references in field paths
+     */
+    private detectCircularReference;
+    /**
+     * Calculate complexity score for a selection set
+     */
+    private calculateComplexityScore;
+    /**
+     * Fix complexity issues in a selection set
+     */
+    private fixComplexityIssues;
+    /**
+     * Generate a cache key for a relationship configuration
+     */
+    private generateCacheKey;
+    /**
+     * Get cached selection set if available
+     */
+    private getCachedSelectionSet;
+    /**
+     * Cache a generated selection set
+     */
+    private cacheSelectionSet;
+    /**
+     * Evict oldest cache entries when cache gets too large
+     */
+    private evictOldestCacheEntries;
+    /**
+     * Get schema version for cache invalidation
+     */
+    private getSchemaVersion;
+    /**
+     * Get cache statistics for debugging
+     */
+    getCacheStats(): {
+        size: number;
+        totalAccesses: number;
+        entries: Array<{
+            key: CacheKey;
+            selectionSet: string[];
+            createdAt: Date;
+            accessCount: number;
+        }>;
+    };
+    /**
+     * Get optimization statistics for debugging
+     */
+    getOptimizationStats(): {
+        displayOptimizationEnabled: boolean;
+        complexityLimits: ComplexityLimits;
+        displayConfig: DisplayOptimizationConfig;
+    };
+    /**
+     * Analyze a selection set for optimization opportunities
+     */
+    analyzeSelectionSetOptimization(selectionSet: string[]): {
+        totalFields: number;
+        displayRelevantFields: number;
+        complexityScore: number;
+        optimizationOpportunities: string[];
+    };
+    /**
+     * Initialize the service with schema data
+     */
+    initializeWithSchema(amplifyOutputs: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectionSetGeneratorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SelectionSetGeneratorService>;
+}
+
 declare class AmplifyAngularCore {
     static ɵfac: i0.ɵɵFactoryDeclaration<AmplifyAngularCore, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<AmplifyAngularCore, "snteam-amplify-angular-core", never, {}, {}, never, never, true, never>;
@@ -98,8 +859,10 @@ declare class FormGroupQuestion<T> extends QuestionBase<T> {
 }
 
 declare class AmplifyModelService {
+    private selectionSetGenerator;
+    private errorHandler;
     private client;
-    constructor();
+    constructor(selectionSetGenerator: SelectionSetGeneratorService, errorHandler: ErrorHandlerService);
     /**
      * Initialize the service with the Amplify client
      * This should be called by the consuming application after Amplify.configure()
@@ -125,12 +888,60 @@ declare class AmplifyModelService {
     deleteRelationship(relModel: string, relId: string): Promise<any>;
     createRelationship(relModel: string, relItem: any): Promise<any> | null;
     getRelationshipFilter(config: any, baseId?: string, removeIds?: string[]): any;
-    getAmplifySelectionSet(config: any, baseId: string): any;
+    /**
+     * 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: RelationshipConfiguration, baseId: string): string[];
     setRelatedSub(config: any, baseId: string): Observable<any> | null;
     /**
-     * @param config {object} - see dynamic-relationship-builder.component getDetailsForManyToMany() for example of building config
+     * 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: RelationshipConfiguration, baseId: string): Observable<any> | null;
+    /**
+     * Get related items with progressive retry logic for GraphQL errors
+     * Implements progressive fallback: original → comprehensive → selective → minimal
+     */
+    private getRelatedItemsWithRetry;
+    /**
+     * Handle GraphQL query errors with retry logic
+     * Enhanced with comprehensive error logging and context
+     */
+    private handleQueryError;
+    /**
+     * Determine if an error should trigger a retry
+     * Enhanced with comprehensive error pattern matching
      */
-    getRelatedItems(config: any, baseId: string): Observable<any> | null;
+    private shouldRetryOnError;
+    /**
+     * Validate that relationship field data is populated in query results
+     * Enhanced with comprehensive error logging
+     */
+    private validateRelationshipFieldPopulation;
+    /**
+     * Log query attempt details
+     */
+    private logQueryAttempt;
+    /**
+     * Log successful query details
+     */
+    private logQuerySuccess;
+    /**
+     * Log query error details
+     */
+    private logQueryError;
+    /**
+     * Log final failure when all retries are exhausted
+     * Enhanced with comprehensive error context and recovery suggestions
+     */
+    private logFinalFailure;
     createItemPromise(model: string, payload: any): Promise<any> | null;
     updateItemForModel(model: string, payload: any): Promise<any> | null;
     deleteItemForModel(model: string, id: string): Promise<any> | null;
@@ -313,13 +1124,16 @@ declare class ConfigurationsComponent implements OnInit {
     ngOnInit(): void;
     get outputs(): any;
     checkAvailableModels(): void;
-    private formatModelLabel;
     populateDefaultFieldConfigs(): Promise<void>;
     deleteAllConfigs(modelName: string): Promise<void>;
     deleteTableConfigs(): Promise<void>;
     deleteFormViews(): Promise<void>;
     deleteListViews(): Promise<void>;
     deleteFieldConfigs(): Promise<void>;
+    populateDefaultTableConfigs(): Promise<void>;
+    private formatModelLabel;
+    private formatFieldLabel;
+    private mapFieldType;
     static ɵfac: i0.ɵɵFactoryDeclaration<ConfigurationsComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<ConfigurationsComponent, "snteam-configurations", never, { "amplifyOutputs": { "alias": "amplifyOutputs"; "required": false; }; }, {}, never, never, true, never>;
 }
@@ -407,14 +1221,63 @@ declare class RecordRelationshipsComponent implements OnInit {
 
 declare class DynamicRelationshipBuilderComponent implements OnInit {
     private ams;
+    private errorHandler;
     m2m: any;
     item: any;
     model: string;
-    m2mItems: any;
-    constructor(ams: AmplifyModelService);
+    m2mItems: any[];
+    errorMessage: string;
+    isLoading: boolean;
+    constructor(ams: AmplifyModelService, errorHandler: ErrorHandlerService);
     modelItem: any;
     readonly dialog: MatDialog;
     ngOnInit(): void;
+    /**
+     * Set error message and clear loading state
+     * Enhanced with comprehensive error context logging
+     */
+    private setError;
+    /**
+     * Clear error message and log recovery
+     */
+    private clearError;
+    /**
+     * Get display name for a relationship item, handling various field names
+     */
+    getDisplayName(relationshipItem: any): string;
+    /**
+     * Get display name for items with partial or missing relationship data
+     */
+    getPartialDisplayName(item: any): string;
+    /**
+     * Check if an item has complete relationship data
+     */
+    hasCompleteRelationshipData(item: any): boolean;
+    /**
+     * Check if an item has partial relationship data (item exists but relationship data is incomplete)
+     */
+    hasPartialRelationshipData(item: any): boolean;
+    /**
+     * Get loading state indicator for relationship data
+     */
+    getRelationshipLoadingState(item: any): 'complete' | 'partial' | 'missing' | 'loading';
+    /**
+     * Get appropriate CSS class for relationship item based on data completeness
+     */
+    getRelationshipItemClass(item: any): string;
+    /**
+     * Get tooltip text for relationship items based on their data state
+     */
+    getRelationshipTooltip(item: any): string;
+    /**
+     * Get summary of data states for all relationship items
+     */
+    getDataStateSummary(): {
+        completeCount: number;
+        partialCount: number;
+        missingCount: number;
+        hasPartialOrMissing: boolean;
+    };
     perhapsAddM2MItem(item: any): Promise<void>;
     setCreateSubscription(): void;
     listItems(): void;
@@ -454,5 +1317,5 @@ declare class ValToTitlePipe implements PipeTransform {
     static ɵpipe: i0.ɵɵPipeDeclaration<ValToTitlePipe, "valToTitle", true>;
 }
 
-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 type { DialogData, RowAction };
+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 };
+export type { AnalysisResult, CacheKey, CachedSelectionSet, ComplexityLimits, ComplexityValidationResult, ConfigurationAnalyzer, DialogData, DisplayOptimizationConfig, FieldAnalysis, ModelField, RelationshipConfiguration, RowAction, SchemaIntrospector, SelectionSetConfig, SelectionSetError, SelectionSetGenerator, SelectionSetResult };