@snteam/amplify-angular-core 1.0.40 → 1.0.41

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

@@ -2296,11 +2296,29 @@ class AmplifyModelService {
     selectionSetGenerator;
     errorHandler;
     client;
+    relationshipConfig = null;
     constructor(selectionSetGenerator, errorHandler) {
         this.selectionSetGenerator = selectionSetGenerator;
         this.errorHandler = errorHandler;
         // Client will be initialized when Amplify is configured by the consuming application
     }
+    /**
+     * Configure the service with relationship selection sets
+     * This should be called by the consuming application to define how relationships should be queried
+     */
+    configure(config) {
+        if (config.relationshipSelectionSets) {
+            this.relationshipConfig = config.relationshipSelectionSets;
+            console.log('AmplifyModelService: Configured with relationship selection sets:', this.relationshipConfig);
+        }
+    }
+    /**
+     * Set relationship selection set configuration directly
+     */
+    setRelationshipConfig(config) {
+        this.relationshipConfig = config;
+        console.log('AmplifyModelService: Updated relationship selection sets configuration:', this.relationshipConfig);
+    }
     /**
      * Initialize the service with the Amplify client
      * This should be called by the consuming application after Amplify.configure()
@@ -2486,9 +2504,8 @@ class AmplifyModelService {
         }
     }
     /**
-     * Generate dynamic selection set for relationship queries
-     * Replaces hardcoded selection set logic with dynamic generation
-     * Enhanced with comprehensive error handling and logging
+     * Get selection set for relationship queries using configuration
+     * This replaces the complex dynamic generation with simple configuration lookup
      * @param config Relationship configuration object
      * @param baseId Base record ID (for compatibility, not used in generation)
      * @returns Array of GraphQL field selectors
@@ -2496,65 +2513,89 @@ class AmplifyModelService {
     getAmplifySelectionSet(config, baseId) {
         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
+                console.warn('AmplifyModelService: Configuration is null or undefined, using minimal fallback');
                 return ['id'];
             }
-            console.log('AmplifyModelService: Generating dynamic selection set for config:', {
+            console.log('AmplifyModelService: Getting selection set for relationship:', {
                 relationshipModel: config.relationshipModelName,
                 fieldName: config.fieldName,
                 baseModelName: config.baseModelName,
                 associatedWith: config.associatedWith,
                 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
-                console.warn('AmplifyModelService: Using minimal fallback selection set due to generator failure');
-                return ['id'];
-            }
-            console.log('AmplifyModelService: Generated selection set:', {
-                config: config.fieldName,
-                selectionSetLength: selectionSet.length,
-                selectionSet,
-                detailedConfig: {
-                    relationshipModelName: config.relationshipModelName,
-                    baseModelName: config.baseModelName,
-                    fieldName: config.fieldName,
-                    associatedWith: config.associatedWith
+            // Try to get selection set from configuration first
+            const configuredSelectionSet = this.getConfiguredSelectionSet(config);
+            if (configuredSelectionSet && configuredSelectionSet.length > 0) {
+                console.log('AmplifyModelService: Using configured selection set:', configuredSelectionSet);
+                return configuredSelectionSet;
+            }
+            // Fall back to default selection set if configured
+            if (this.relationshipConfig?.defaultSelectionSet && this.relationshipConfig.defaultSelectionSet.length > 0) {
+                console.log('AmplifyModelService: Using default configured selection set:', this.relationshipConfig.defaultSelectionSet);
+                return this.relationshipConfig.defaultSelectionSet;
+            }
+            // Fall back to dynamic generation if enabled and no configuration found
+            if (this.relationshipConfig?.enableFallback !== false) {
+                console.log('AmplifyModelService: No configuration found, falling back to dynamic generation');
+                const dynamicSelectionSet = this.selectionSetGenerator.generateSelectionSet(config);
+                if (dynamicSelectionSet && dynamicSelectionSet.length > 0) {
+                    console.log('AmplifyModelService: Using dynamic selection set:', dynamicSelectionSet);
+                    return dynamicSelectionSet;
                 }
-            });
-            return selectionSet;
+            }
+            // Final fallback - use a simple, predictable selection set
+            const fallbackSelectionSet = this.generateSimpleFallbackSelectionSet(config);
+            console.log('AmplifyModelService: Using simple fallback selection set:', fallbackSelectionSet);
+            return fallbackSelectionSet;
         }
         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)]);
+            console.error('AmplifyModelService: Error getting selection set, using minimal fallback:', error);
+            return ['id'];
         }
     }
+    /**
+     * Get configured selection set for a specific relationship
+     */
+    getConfiguredSelectionSet(config) {
+        if (!this.relationshipConfig?.relationships) {
+            return null;
+        }
+        // Look for exact match first
+        const exactMatch = this.relationshipConfig.relationships.find(rel => rel.relationshipModel === config.relationshipModelName &&
+            rel.fieldName === config.fieldName);
+        if (exactMatch) {
+            console.log('AmplifyModelService: Found exact configuration match:', exactMatch);
+            return exactMatch.selectionSet;
+        }
+        // Look for relationship model match
+        const modelMatch = this.relationshipConfig.relationships.find(rel => rel.relationshipModel === config.relationshipModelName);
+        if (modelMatch) {
+            console.log('AmplifyModelService: Found relationship model match:', modelMatch);
+            return modelMatch.selectionSet;
+        }
+        // Look for field name match
+        const fieldMatch = this.relationshipConfig.relationships.find(rel => rel.fieldName === config.fieldName);
+        if (fieldMatch) {
+            console.log('AmplifyModelService: Found field name match:', fieldMatch);
+            return fieldMatch.selectionSet;
+        }
+        return null;
+    }
+    /**
+     * Generate a simple, predictable fallback selection set
+     */
+    generateSimpleFallbackSelectionSet(config) {
+        const selectionSet = ['id'];
+        if (config.fieldName) {
+            // Add the relationship field itself
+            selectionSet.push(config.fieldName);
+            // Add common nested fields
+            selectionSet.push(`${config.fieldName}.id`);
+            selectionSet.push(`${config.fieldName}.name`);
+            selectionSet.push(`${config.fieldName}.title`);
+        }
+        return selectionSet;
+    }
     setRelatedSub(config, baseId) {
         if (!this.client) {
             console.error('AmplifyModelService: Client not initialized. Call initializeClient() first.');
@@ -2757,178 +2798,44 @@ class AmplifyModelService {
     }
     /**
      * Validate that relationship field data is populated in query results
-     * Enhanced with comprehensive error logging and very flexible validation
+     * Simplified validation that's more predictable and easier to debug
      */
     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),
-                    resultType: typeof result,
-                    resultKeys: result ? Object.keys(result) : []
-                });
+                console.warn('AmplifyModelService: Query result is missing or has no data property');
                 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;
-            let recordsWithAnyRelationshipData = 0;
+            if (records.length === 0) {
+                console.warn('AmplifyModelService: No records returned from query');
+                return false;
+            }
             console.log(`AmplifyModelService: Validating relationship field '${config.fieldName}' in ${records.length} records`);
+            // Simple validation: if we have records, consider it successful
+            // The actual relationship data validation will happen at the UI level
+            let hasAnyData = false;
             for (let i = 0; i < records.length; i++) {
                 const record = records[i];
-                if (!record)
-                    continue;
-                console.log(`AmplifyModelService: Checking record ${i}:`, {
-                    recordKeys: Object.keys(record),
-                    fieldName: config.fieldName,
-                    fieldValue: record[config.fieldName],
-                    fieldType: typeof record[config.fieldName]
-                });
-                const relationshipData = record[config.fieldName];
-                // Strategy 1: Check for fully populated relationship (object with data)
-                if (relationshipData !== undefined && relationshipData !== null) {
-                    console.log(`AmplifyModelService: Record ${i} has relationship data:`, relationshipData);
-                    // If it's an object with properties, consider it populated
-                    if (typeof relationshipData === 'object' && Object.keys(relationshipData).length > 0) {
-                        populatedCount++;
-                        recordsWithAnyRelationshipData++;
-                    }
-                    // If it's a non-null primitive value, also consider it populated
-                    else if (typeof relationshipData !== 'object') {
-                        populatedCount++;
-                        recordsWithAnyRelationshipData++;
-                    }
-                    // If it's an empty object or array, consider it partially populated
-                    else {
-                        partiallyPopulatedCount++;
-                        recordsWithAnyRelationshipData++;
-                    }
-                }
-                // Strategy 2: 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) {
-                    console.log(`AmplifyModelService: Record ${i} has nested relationship data for field '${config.fieldName}'`);
-                    populatedCount++;
-                    recordsWithAnyRelationshipData++;
-                }
-                // Strategy 3: Check for any field that contains the relationship name
-                // This is a very permissive check for cases where the field structure is different
-                const hasAnyRelatedField = this.hasAnyRelatedField(record, config.fieldName);
-                if (hasAnyRelatedField) {
-                    console.log(`AmplifyModelService: Record ${i} has some related field data for '${config.fieldName}'`);
-                    recordsWithAnyRelationshipData++;
+                if (record && typeof record === 'object' && Object.keys(record).length > 0) {
+                    hasAnyData = true;
+                    console.log(`AmplifyModelService: Record ${i} has data:`, Object.keys(record));
+                    break;
                 }
             }
-            // Strategy 4: Very permissive validation - if we have ANY records with ANY relationship data, consider it valid
-            // This is to handle cases where the relationship structure is different than expected
-            const totalValidRecords = Math.max(populatedCount + partiallyPopulatedCount, recordsWithAnyRelationshipData);
-            console.log(`AmplifyModelService: Relationship validation summary:`, {
-                fieldName: config.fieldName,
-                totalRecords: records.length,
-                populatedCount,
-                partiallyPopulatedCount,
-                recordsWithAnyRelationshipData,
-                totalValidRecords,
-                validationPassed: totalValidRecords > 0
-            });
-            if (totalValidRecords === 0) {
-                // Log very detailed information about what we found
-                const sampleRecord = records[0];
-                const detailedError = {
-                    method: 'validateRelationshipFieldPopulation',
-                    recordCount: records.length,
-                    populatedCount,
-                    partiallyPopulatedCount,
-                    recordsWithAnyRelationshipData,
-                    fieldName: config.fieldName,
-                    sampleRecord: sampleRecord ? {
-                        keys: Object.keys(sampleRecord),
-                        values: sampleRecord,
-                        fieldValue: sampleRecord[config.fieldName],
-                        fieldType: typeof sampleRecord[config.fieldName]
-                    } : null,
-                    allRecordKeys: records.map((r) => r ? Object.keys(r) : []),
-                    config: {
-                        relationshipModelName: config.relationshipModelName,
-                        baseModelName: config.baseModelName,
-                        fieldName: config.fieldName,
-                        associatedWith: config.associatedWith
-                    }
-                };
-                this.errorHandler.logSelectionSetError(SelectionSetErrorType.FIELD_NOT_FOUND, `No records have relationship field '${config.fieldName}' populated - detailed analysis shows no relationship data found`, config, undefined, detailedError);
-                console.error(`AmplifyModelService: DETAILED VALIDATION FAILURE for field '${config.fieldName}':`, detailedError);
-                // TEMPORARY: For debugging, let's be even more permissive and return true if we have any records at all
-                // This will help us see what data is actually being processed
-                if (records.length > 0) {
-                    console.warn(`AmplifyModelService: TEMPORARY DEBUG MODE - Allowing validation to pass despite no relationship data found`);
-                    return true;
-                }
+            if (!hasAnyData) {
+                console.warn('AmplifyModelService: No valid records found in query result');
                 return false;
             }
-            console.log(`AmplifyModelService: Relationship field validation SUCCESSFUL: ${totalValidRecords}/${records.length} records have some form of relationship data for '${config.fieldName}' field`);
+            console.log(`AmplifyModelService: Relationship validation successful - found ${records.length} records with data`);
             return true;
         }
         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);
-            // In case of validation error, be permissive and return true to avoid blocking the UI
-            console.warn('AmplifyModelService: Validation error occurred, allowing relationship to proceed');
+            // Be permissive on validation errors
             return true;
         }
     }
-    /**
-     * 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) {
-                    console.log(`AmplifyModelService: Found nested relationship data: ${key} = ${value}`);
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-    /**
-     * Check if a record has any field that might be related to the relationship field
-     * This is a very permissive check for debugging purposes
-     */
-    hasAnyRelatedField(record, fieldName) {
-        if (!record || typeof record !== 'object') {
-            return false;
-        }
-        const fieldNameLower = fieldName.toLowerCase();
-        for (const key of Object.keys(record)) {
-            const keyLower = key.toLowerCase();
-            // Check if the key contains the field name or vice versa
-            if (keyLower.includes(fieldNameLower) || fieldNameLower.includes(keyLower)) {
-                const value = record[key];
-                if (value !== undefined && value !== null) {
-                    console.log(`AmplifyModelService: Found potentially related field: ${key} = ${value}`);
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
     /**
      * Log query attempt details
      */