@snteam/amplify-angular-core 1.0.37 → 1.0.38

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

@@ -647,6 +647,8 @@ class ConfigurationAnalyzerService {
         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
@@ -726,7 +728,7 @@ class ConfigurationAnalyzerService {
         return selectors;
     }
     /**
-     * Enhanced field selector determination that supports nested paths
+     * Enhanced field selector determination that supports nested paths and handles different relationship types
      */
     determineFieldSelectorsEnhanced(targetModel, fieldName) {
         if (!targetModel) {
@@ -738,8 +740,28 @@ class ConfigurationAnalyzerService {
         if (effectiveFieldName.includes('.')) {
             return this.generateNestedFieldSelectors(effectiveFieldName, targetModel);
         }
-        // Use the standard field selector generation for simple relationships
-        return this.determineFieldSelectors(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)
@@ -1559,16 +1581,33 @@ class SelectionSetGeneratorService {
      */
     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
-        return this.applyComplexityLimits(optimizedSet);
+        const finalSet = this.applyComplexityLimits(optimizedSet);
+        console.log('SelectionSetGenerator: Final configuration-based selection set:', finalSet);
+        return finalSet;
     }
     /**
      * Apply display optimization to prioritize display-relevant fields
@@ -2709,7 +2748,7 @@ class AmplifyModelService {
     }
     /**
      * Validate that relationship field data is populated in query results
-     * Enhanced with comprehensive error logging
+     * Enhanced with comprehensive error logging and flexible validation
      */
     validateRelationshipFieldPopulation(result, config) {
         try {
@@ -2724,28 +2763,56 @@ class AmplifyModelService {
             // 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 && record[config.fieldName] !== undefined && record[config.fieldName] !== null) {
+                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 (populatedCount === 0) {
-                // Log warning if no relationship fields are populated
+            // 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]) : [],
-                    fieldName: config.fieldName
+                    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]
+                    sampleRecord: records[0],
+                    sampleRelationshipValue: records[0] ? records[0][config.fieldName] : undefined
                 });
                 return false;
             }
-            console.log(`AmplifyModelService: Relationship field validation successful: ${populatedCount}/${records.length} records have populated '${config.fieldName}' field`);
+            console.log(`AmplifyModelService: Relationship field validation successful: ${populatedCount}/${records.length} records fully populated, ${partiallyPopulatedCount} partially populated for '${config.fieldName}' field`);
             return true;
         }
         catch (error) {
@@ -2760,6 +2827,26 @@ class AmplifyModelService {
             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
      */