Datastore: Create parent and child entity in an entity group transaction?

After reading about Google Datastore concepts/theory I started using the Go datastore package

Scenario:
Kinds User and LinkedAccount require that every user has one or more linked accounts (yay 3rd party login). For strong consistency, LinkedAccounts will be children of the associated User. New User creation then involves creating both a User and a LinkedAccount, never just one.

User creation seems like the perfect use case for transactions. If, say LinkedAccount creation fails, the transaction rolls back an fails. This doesn't currently seem possible. The goal is to create a parent and then a child within a transaction.

According to docs

> All Datastore operations in a transaction must operate on entities in
> the same entity group if the transaction is a single group transaction

We want a new User and LinkedAccount to be in the same group, so to me it sounds like Datastore should support this scenario. My fear is that the intended meaning is that operations on existing entities in the same group can be performed in a single transaction.

tx, err := datastore.NewTransaction(ctx)
if err != nil {
	return err
}
incompleteUserKey := datastore.NewIncompleteKey(ctx, "User", nil)
pendingKey, err := tx.Put(incompleteUserKey, user)
if err != nil {
	return err
}
incompleteLinkedAccountKey := datastore.NewIncompleteKey(ctx, "GithubAccount", incompleteUserKey)
// also tried PendingKey as parent, but its a separate struct type
_, err = tx.Put(incompleteLinkedAccountKey, linkedAccount)
if err != nil {
	return err
}
// attempt to commit
if _, err := tx.Commit(); err != nil {
	return err
}
return nil

From the library source its clear why this doesn't work. PendingKey's aren't keys and incomplete keys can't be used as parents.

Is this a necessary limitation of Datastore or of the library? For those experienced with this type of requirement, did you just sacrifice the strong consistency and make both kinds global?

For Google-ability:

• datastore: invalid key
• datastore: cannot use pendingKey as type *"google.golang.org/cloud/datastore".Key

One thing to note is that transactions in the Cloud Datastore API can operate on up to 25 entity groups, but this doesn't answer the question of how to create two entities in the same entity group as part of a single transaction.

There are a few ways to approach this (note that this applies to any use of the Cloud Datastore API, not just the gcloud-golang library):

1. Use a (string) name for the parent key instead of having Datastore automatically assign a numeric ID:

   parentKey := datastore.NewKey(ctx, "Parent", "parent-name", 0, nil)
   childKey := datastore.NewIncompleteKey(ctx, "Child", parentKey)
   

2. Make an explicit call to AllocateIds to have the Datastore pick a numeric ID for the parent key:

   incompleteKeys := [1]*datastore.Key{datastore.NewIncompleteKey(ctx, "Parent", nil)}
   completeKeys, err := datastore.AllocateIDs(ctx, incompleteKeys)
   if err != nil {
     // ...
   }
   parentKey := completeKeys[0]
   childKey := datastore.NewIncompleteKey(ctx, "Child", parentKey)