add SQL and GraphQL tests for PostComment4V2

Author: lawmicha

Amplify/Categories/DataStore/Model/Internal/ModelProvider.swift

@@ -41,6 +41,6 @@ public protocol ModelProvider {
 }
 
 public enum ModelProviderState<Element: Model> {
-    case notLoaded(identifier: String)
+    case notLoaded(identifiers: [String: String])
     case loaded(Element?)
 }

AmplifyPlugins/API/Sources/AWSAPIPlugin/Core/AppSyncListDecoder.swift

@@ -56,7 +56,7 @@ public struct AppSyncListDecoder: ModelListDecoder {
 
 public struct AppSyncModelDecoder: ModelProviderDecoder {
     public static func shouldDecode<ModelType: Model>(modelType: ModelType.Type, decoder: Decoder) -> Bool {
-        if (try? AppSyncPartialModelMetadata(from: decoder)) != nil {
+        if (try? AppSyncModelIdentifierMetadata(from: decoder)) != nil {
             return true
         }
 
@@ -80,7 +80,7 @@ public struct AppSyncModelDecoder: ModelProviderDecoder {
                                                            decoder: Decoder) throws -> AppSyncModelProvider<ModelType>? {
         if let model = try? ModelType.init(from: decoder) {
             return AppSyncModelProvider(model: model)
-        } else if let metadata = try? AppSyncPartialModelMetadata.init(from: decoder) {
+        } else if let metadata = try? AppSyncModelIdentifierMetadata.init(from: decoder) {
             return AppSyncModelProvider<ModelType>(metadata: metadata)
         }
         let json = try JSONValue(from: decoder)

AmplifyPlugins/API/Sources/AWSAPIPlugin/Core/AppSyncListProvider.swift

@@ -14,15 +14,15 @@ public class AppSyncModelProvider<ModelType: Model>: ModelProvider {
     let apiName: String?
 
     enum LoadedState {
-        case notLoaded(identifier: String)
+        case notLoaded(identifiers: [String: String])
         case loaded(model: ModelType?)
     }
 
     var loadedState: LoadedState
 
     // init(AppSyncModelMetadata) creates a notLoaded provider
-    convenience init(metadata: AppSyncPartialModelMetadata) {
-        self.init(identifier: metadata.identifier,
+    convenience init(metadata: AppSyncModelIdentifierMetadata) {
+        self.init(identifiers: metadata.identifiers,
                   apiName: metadata.apiName)
     }
 
@@ -33,8 +33,8 @@ public class AppSyncModelProvider<ModelType: Model>: ModelProvider {
     }
 
     // Initializer for not loaded state
-    init(identifier: String, apiName: String? = nil) {
-        self.loadedState = .notLoaded(identifier: identifier)
+    init(identifiers: [String: String], apiName: String? = nil) {
+        self.loadedState = .notLoaded(identifiers: identifiers)
         self.apiName = apiName
     }
 
@@ -44,11 +44,15 @@ public class AppSyncModelProvider<ModelType: Model>: ModelProvider {
     public func load() async throws -> ModelType? {
 
         switch loadedState {
-        case .notLoaded(let identifier):
+        case .notLoaded(let identifiers):
+            // TODO: account for more than one identifier
+            guard let identifier = identifiers.first else {
+                throw CoreError.operation("CPK not yet implemented", "", nil)
+            }
             let request = GraphQLRequest<ModelType?>.getQuery(responseType: ModelType.self,
-                                                            modelSchema: ModelType.schema,
-                                                            identifier: identifier,
-                                                            apiName: apiName)
+                                                              modelSchema: ModelType.schema,
+                                                              identifier: identifier.value,
+                                                              apiName: apiName)
             do {
                 let graphQLResponse = try await Amplify.API.query(request: request)
                 switch graphQLResponse {
@@ -76,8 +80,8 @@ public class AppSyncModelProvider<ModelType: Model>: ModelProvider {
 
     public func getState() -> ModelProviderState<ModelType> {
         switch loadedState {
-        case .notLoaded(let identifier):
-            return .notLoaded(identifier: identifier)
+        case .notLoaded(let identifiers):
+            return .notLoaded(identifiers: identifiers)
         case .loaded(let model):
             return .loaded(model)
         }

AmplifyPlugins/API/Sources/AWSAPIPlugin/Core/AppSyncModelMetadata.swift

@@ -16,8 +16,9 @@ public struct AppSyncModelMetadata: Codable {
 }
 
 /// Metadata that contains partial information of a model
-public struct AppSyncPartialModelMetadata: Codable {
-    let identifier: String
+// TODO this should expand to more than just the identifier for composite keys.
+public struct AppSyncModelIdentifierMetadata: Codable {
+    let identifiers: [String: String]
     let apiName: String?
 }
 
@@ -28,7 +29,7 @@ public struct AppSyncModelMetadataUtils {
     // It needs to have the Model type from `__typename` so it can populate it as "associatedField"
     //
     // This check is currently broken for CPK use cases since the identifier may not be named `id` anymore
-    // and also can be a composite key made up of multiple fields.
+    // and can be a composite key made up of multiple fields.
     static func shouldAddMetadata(toModel graphQLData: JSONValue) -> Bool {
         guard case let .object(modelJSON) = graphQLData,
               case let .string(modelName) = modelJSON["__typename"],
@@ -81,17 +82,29 @@ public struct AppSyncModelMetadataUtils {
         encoder.dateEncodingStrategy = ModelDateFormatting.encodingStrategy
         let decoder = JSONDecoder()
         decoder.dateDecodingStrategy = ModelDateFormatting.decodingStrategy
-        // Iterate over the associations of the model and for each association, store its association data when
-        // the object at the association is empty. For example, if the modelType is a Post and has a field that is an
-        // array association like Comment, store the post's identifier and the ModelField name of the parent, ie.
-        // "post" in the comments object as metadata.
+        
+        // Iterate over the associations of the model and for each association, either create the identifier metadata
+        // for lazy loading belongs-to or create the model association metadata for lazy loading has-many.
+        // The metadata gets decoded to the LazyModel and List implementations respectively.
         for modelField in modelSchema.fields.values {
 
+            // Handle Belongs-to associations. For the current `modelField` that is a belongs-to association,
+            // retrieve the data and attempt to decode to the association's modelType. If it can be decoded,
+            // this means it is eager loaded and does not need to be lazy loaded. If it cannot, extract the
+            // identifiers out of the data in the AppSyncModelIdentifierMetadata and store that in place for
+            // the LazyModel to decode from.
             if !modelField.isArray && modelField.hasAssociation,
                let nestedModelJSON = modelJSON[modelField.name],
-               let partialModelMetadata = isPartialModel(nestedModelJSON, apiName: apiName) {
-            
-                if let serializedMetadata = try? encoder.encode(partialModelMetadata),
+               case .object(let modelObject) = nestedModelJSON,
+               let associatedModelName = modelField.associatedModelName,
+               let associatedModelType = ModelRegistry.modelType(from: associatedModelName),
+               let serializedModelObject = try? encoder.encode(modelObject),
+               !((try? decoder.decode(associatedModelType.self, from: serializedModelObject)) != nil),
+               let modelIdentifierMetadata = containsOnlyIdentifiers(associatedModelType,
+                                                                     modelObject: modelObject,
+                                                                     apiName: apiName) {
+                
+                if let serializedMetadata = try? encoder.encode(modelIdentifierMetadata),
                    let metadataJSON = try? decoder.decode(JSONValue.self, from: serializedMetadata) {
                     modelJSON.updateValue(metadataJSON, forKey: modelField.name)
                 } else {
@@ -101,6 +114,11 @@ public struct AppSyncModelMetadataUtils {
                 }
             }
 
+            // Handle Has-many. Store the association data (parent's identifier and field name) only when the model
+            // at the association is empty. If it's not empty, that means the has-many has been eager loaded.
+            // For example, when traversing the Post's fields and encounters the has-many association Comment, store
+            // the association metadata containing the post's identifier at comment, to be decoded to the List
+            // This allows the list to perform lazy loading of the Comments with a filter on the post's identifier.
             if modelField.isArray && modelField.hasAssociation,
                let associatedField = modelField.associatedField,
                modelJSON[modelField.name] == nil {
@@ -121,24 +139,25 @@ public struct AppSyncModelMetadataUtils {
         return JSONValue.object(modelJSON)
     }
 
-    // A partial model is when only the values of the identifier of the model exists, and nothing else.
-    // Traverse of the primary keys of the model, and check if there's exactly those values exists.
-    // This means that the model are missing required/optional fields that are not the identifier of the model.
-    // TODO: This code needs to account for CPK.
-    static func isPartialModel(_ modelJSON: JSONValue, apiName: String?) -> AppSyncPartialModelMetadata? {
-        guard case .object(let modelObject) = modelJSON else {
-            return nil
-        }
+    // At this point, we know the model cannot be decoded to the fully model
+    // so extract the primary key and values out.
+    static func containsOnlyIdentifiers(_ associatedModel: Model.Type,
+                                        modelObject: [String: JSONValue],
+                                        apiName: String?) -> AppSyncModelIdentifierMetadata? {
+        let primarykeys = associatedModel.schema.primaryKey
+        print("primaryKeys \(primarykeys)")
 
-        // TODO: This should be based on the number of fields that make up the identifier + __typename
-        guard modelObject.count == 2 else {
-            return nil
+        var identifiers = [String: String]()
+        for identifierField in primarykeys.fields {
+            if case .string(let id) = modelObject[identifierField.name] {
+                print("Found key value \(identifierField.name) value: \(id)")
+                identifiers.updateValue(id, forKey: identifierField.name)
+            }
         }
-        
-        if case .string(let id) = modelObject["id"] {
-            return AppSyncPartialModelMetadata(identifier: id, apiName: apiName)
+        if !identifiers.isEmpty {
+            return AppSyncModelIdentifierMetadata(identifiers: identifiers, apiName: apiName)
+        } else {
+            return nil
         }
-        
-        return nil
     }
 }

AmplifyPlugins/API/Sources/AWSAPIPlugin/Support/Decode/GraphQLResponseDecoder+DecodeData.swift

@@ -40,7 +40,7 @@ extension GraphQLResponseDecoder {
         if request.responseType == AnyModel.self { // 2
             let anyModel = try AnyModel(modelJSON: graphQLData)
             serializedJSON = try encoder.encode(anyModel)
-        } else if request.responseType is ModelListMarker.Type, // 2
+        } else if request.responseType is ModelListMarker.Type, // 3
                   case .object(var graphQLDataObject) = graphQLData,
                   case .array(var graphQLDataArray) = graphQLDataObject["items"] {
             for (index, item) in graphQLDataArray.enumerated() {