@snteam/amplify-angular-core 1.0.39 → 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,55 +2513,88 @@ 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
-                return ['id'];
+            // 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;
+                }
             }
-            console.log('AmplifyModelService: Generated selection set:', {
-                config: config.fieldName,
-                selectionSetLength: selectionSet.length,
-                selectionSet
-            });
-            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) {
@@ -2748,104 +2798,43 @@ class AmplifyModelService {
     }
     /**
      * Validate that relationship field data is populated in query results
-     * Enhanced with comprehensive error logging and 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)
-                });
+                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;
-            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++;
+            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 && typeof record === 'object' && Object.keys(record).length > 0) {
+                    hasAnyData = true;
+                    console.log(`AmplifyModelService: Record ${i} has data:`, Object.keys(record));
+                    break;
                 }
             }
-            // 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
-                });
+            if (!hasAnyData) {
+                console.warn('AmplifyModelService: No valid records found in query result');
                 return false;
             }
-            console.log(`AmplifyModelService: Relationship field validation successful: ${populatedCount}/${records.length} records fully populated, ${partiallyPopulatedCount} partially populated 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);
-            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;
-                }
-            }
+            // Be permissive on validation errors
+            return true;
         }
-        return false;
     }
     /**
      * Log query attempt details