Unexpected change in Amplify.API.mutate behavior "Cannot return null for non-nullable type within parent"

[uxian]

Describe the bug

Error:

Failed to create graphql GraphQLResponseError<Like>: GraphQL service returned a partially-successful response containing errors: [Amplify.GraphQLError(message: "Cannot return null for non-nullable type: \'ID\' within parent \'User\' (/createLike/user/id)", locations: nil, path: Optional([Amplify.JSONValue.string("createLike"), Amplify.JSONValue.string("user"), Amplify.JSONValue.string("id")]), extensions: nil)]

Following code used to work, but after upgrading to newer version of Amplify, it starts to fall apart. I don't need associated entities when doing Amplify.API.mutate, and I suppose the backend shouldn't query associated entities by default, but somehow the response deserializer start to demand the associated entity which supposed to be optional.

        let like = Like(
            subjectId: subjectId,
            userId: userId,
            subjectType: subjectType,
            subjectOwnerId: subjectOwnerId
        )
        
        let request: GraphQLRequest<Like> = toLike ? .create(like) : .delete(like)
        
        let result = try await Amplify.API.mutate(request: request)

Following are model schema

type Like @model 
  @auth(rules: [
    { allow: private, provider: userPools, operations: [read] },
    { allow: owner, provider: userPools, operations: [create, update, delete], ownerField: "userId", identityClaim: "sub" }
  ]) {
  subjectId: ID! @primaryKey(sortKeyFields: ["userId"])
  userId: ID!
  subjectType: String
  subjectOwnerId: ID
  user: User @hasOne(fields: ["userId"])
}

type User @model {
  id: ID!
  name: String
  portrait: String
  bio: String
  isDeleted: Boolean
  createdAt: AWSDateTime
  updatedAt: AWSDateTime
}

Steps To Reproduce

See code above

Expected behavior

should not throw exception

Amplify Framework Version

2.29.2

Amplify Categories

API

Dependency manager

Swift PM

Swift version

5.x

CLI version

12.13.0

Xcode version

15.3

Relevant log output

<details>
<summary>Log Messages</summary>


INSERT LOG MESSAGES HERE

```

Is this a regression?

Yes

Regression additional context

No response

Platforms

iOS

OS Version

17.0

Device

iPhone14

Specific to simulators

No response

Additional context

No response

[uxian]

I've just updated Amplify version to latest 2.44.0, the issue still exists

[uxian]

I figured the problem, the GraphQLRequest query builder tries to dump all fields into graphql query body (document), including the associated fields, however those fields with association are not returned in response. Here is my workaround, tries to remove any association from the generated graphql mutation query document. Looking forward to a permanent solution.

extension GraphQLRequest {
    public static func createFix<M: Model>(
        _ model: M) -> GraphQLRequest<M> {
            let request = create(model)
            return removeFieldsWithAssociation(request)
    }
    
    public static func deleteFix<M: Model>(
        _ model: M) -> GraphQLRequest<M> {
            let request = delete(model)
            return removeFieldsWithAssociation(request)
    }
    
    public static func updateFix<M: Model>(
        _ model: M) -> GraphQLRequest<M> {
            let request = update(model)
            return removeFieldsWithAssociation(request)
    }
    
    private static func findFieldsWithAssociation(_ schema: ModelSchema) -> [ModelField] {
        return schema.fields.values.filter { field in
            if case .belongsTo = field.association {
                return true
            }
            if case .hasMany = field.association {
                return true
            }
            if case .hasOne = field.association {
                return true
            }
            return false
        }
    }
    
    private static func removeFieldsWithAssociation<M: Model>(_ request: GraphQLRequest<M>) -> GraphQLRequest<M> {
        let document = request.document
        
        // Find fields with associations
        let fieldsToRemove = findFieldsWithAssociation(request.responseType.schema)
        
        // Remove fields from document string
        var modifiedDocument = document
        for field in fieldsToRemove {
            // Remove the field and any nested selections
            let pattern = "\(field.name)\\s*\\{[^}]*\\}"
            if let range = modifiedDocument.range(of: pattern, options: .regularExpression) {
                modifiedDocument.removeSubrange(range)
            } else {
                // If no nested selections, just remove the field name
                if let range = modifiedDocument.range(of: "\(field.name)\\s*", options: .regularExpression) {
                    modifiedDocument.removeSubrange(range)
                }
            }
        }
        
        // Create new request with modified document
        return GraphQLRequest<M>(
            document: modifiedDocument,
            variables: request.variables,
            responseType: M.self,
            decodePath: request.decodePath,
            options: request.options
        )
    }
}

[mattcreaser]

Hi @uxian. Glad you have a workaround available. I've marked this as a bug pending further investigation.

[jongminjang]

I have same problem

I tried building sample data

const schema = a.schema({
  Member: a.model({
    name: a.string().required(),
    // 1. Create a reference field
    teamId: a.id(),
    // 2. Create a belongsTo relationship with the reference field
    team: a.belongsTo('Team', 'teamId'),
  }),

  Team: a.model({
    mantra: a.string().required(),
    // 3. Create a hasMany relationship with the reference field
    //    from the `Member`s model.
    members: a.hasMany('Member', 'teamId'),
  }),
}).authorization((allow) => allow.publicApiKey());

above structure does not cause any problem.
but if I edit authorizations to

.authorization(allow => [ allow.owner() ])

then creating or updating instance of team ends with error.

when I execute creating a member, framework issues following command.

mutation CreateMember($input: CreateMemberInput!) {
  createMember(input: $input) {
    id
    createdAt
    name
    updatedAt
    team {
      id
      __typename
    }
    __typename
  }
}

On appsync side, after inserting member to database it resolves team then executing pipeline.

Amplify creates two functions for a pipeline of team

1. Memberteamauth0Function
2. MemberTeamDataResolverFn

In Memberteamauth0Function, we can see these

## [Start] Check if subscriptions is protected. **
#if( $util.defaultIfNull($ctx.source.get("__operation"), null) == "Mutation" )
  $util.qr($ctx.stash.put("deniedField", true))
#end
## [End] Check if subscriptions is protected. **

and in MemberTeamDataResolverFn there is a code like this

#if( $ctx.stash.deniedField )
  #return($util.toJson(null))
#end

I think appsync should not includes team { id } in mutation, because in Modeling relationships section from the documentation says like this

With Amplify Data Construct @aws-amplify/data-construct@1.8.4, an improvement was made to how relational field data is handled in subscriptions when different authorization rules apply to related models in a schema

[jongminjang]

Hi @mattcreaser

I found an issue related this issue.

Relation ship when authorization is owner cannot access a parent upon creation

thanks