What are good CRUD verb semantics for nested mutations in graphql?

Question

It appears that nested objects in graphql mutations inherit the verb semantics from the parent object. This leads to questions about what the CRUD semantics should be for nested mutations.

For example if I wish to create an object and join it an existing associated object while updating that existing object then the parent object semantics are create and the nested objects semantics are an update. However GraphQL doesn't explicitly allow mixed verbs in a single atomic mutation (AFAICT).

Here's a truth table that shows some issues with when a nested object is in the database or in the mutation, or both:

| in mutation| in database| action on create | action on update | Notes 
|------------|------------|------------------|------------------|-------
| False      | False      | create if rule   | create if rule   | a rule might be cardinality === 1.
| False      | True       | None             | None             | no harm no foul
| True       | False      | Create           | Create? Err?     | better ask for ID back or will have to query edges later
| True       | True       | Update?  Err?    | Update           | what if the mutation doesn't contain the ID?

Note that the "action on update" requires an ID in the mutation, or it would turn into a create or an error depending on business rules.

One way to deal with nested objects is treat them as an update if an ID was included. This will lead to accidental creation of nested objects when a coding error occurs. It's also ugly semantics.

A second way is to treat the verb for the parent object as the same verb for the nested object, except on creates if the nested object has an ID present that nested object is treated as an update.

A third alternative is to require multiple mutations to treat nested objects using the returned IDs for the next mutation. That's 3 round trip times, and it destroys the natural atomicity of a single mutation, which will result in a huge consistency problem.

What are the best verb semantics for nested objects for creation and update?

The following is an explicit example. An answer would show the mutation for the scenarios in the table above that are ambiguous.

O1<----hasa---->O2

O1 {
  id: "1234",
  descr: "Object1",
  someAttr: "foo"
}

O2 {
  id: "5678",
  descr:  "Object2",
  someOtherAttr: "bar"
}

hasa {
  id1: "1234",
  id2: "5678",
  type: "hasa"
  edgeAttr: "someRelationAttr"
}

example creation mutation for the above:

mutation { O1Create(
  descr: "Object1",
  someAttr: "foo",
  hasa {
    edgeAttr: "someRelationAttr",
    O2 { 
      descr: "Object2",
      someOtherAttr: "bar"
    } 
  }   
)}

I'd like to know what good choices are for the O1Create mutation when O2 is already in the database. I'd also like to do know what good choices are for O1Update for when O2 is NOT in the database.