Api-Platform graphql - create multiple items in one mutation

Question

I have an User entity that can add his/hers contacts from Google using GooglePeopleApi.

The API provides an array of contacts to the front-end as it is (Nextjs). The question is how to insert all those contacts in one single mutation.

I could, of course, have the front-end loop through the array and post the contacts one by one, but that is a bit silly.

It should be possible to create a type array with the Contact input and then, with that, set up a customArgsMutation. ( I've seen some examples of that from Hasura ).

Entity wise, it looks like this for now ( only relevant code ):

User.php

 ....
/**
 * @ORM\OneToMany(targetEntity="App\Entity\Contact", mappedBy="user")
 * @Groups({"put-contacts", "get-admin", "get-owner"})
 */
private $contacts;

Contact.php

/**
* @ApiResource(
*      attributes={"pagination_enabled"=false},
*      graphql={
*          "item_query"={
*              "normalization_context"={"groups"={"get-admin", "get-owner"}},
*          },
*          "collection_query"={
*              "normalization_context"={"groups"={"get-admin", "get-owner"}},
*          },
*          "delete"={"security"="is_granted('IS_AUTHENTICATED_FULLY') and object.getUser() == user"},
*          "create"={
*              "security"="is_granted('IS_AUTHENTICATED_FULLY')",
*              "denormalization_context"={"groups"={"post", "put"}},
*              "normalization_context"={"groups"={"get-owner", "get-admin"}},
*          },
*      }
* )
* @ORM\Entity(repositoryClass="App\Repository\ContactRepository")
*/
class Contact
{
/**
 * @ORM\Id()
 * @ORM\GeneratedValue()
 * @ORM\Column(type="integer")
 */
private $id;

/**
 * @ORM\ManyToOne(targetEntity="App\Entity\User", inversedBy="contacts")
 * @Groups({"post", "get-admin", "get-owner"})
 */
private $user;

/**
 * @ORM\Column(type="string", length=180)
 * @Groups({"post", "put", "get-admin", "get-owner"})
 */
private $email;

/**
 * @ORM\Column(type="string", length=180, nullable=true)
 * @Groups({"post", "put", "get-admin", "get-owner"})
 */
private $familyName;

/**
 * @ORM\Column(type="string", length=180, nullable=true)
 * @Groups({"post", "put", "get-admin", "get-owner"})
 */
private $givenName;

/**
 * @ORM\Column(type="string", length=180, nullable=true)
 * @Groups({"post", "put", "get-admin", "get-owner"})
 */
private $displayName;

From graphiql, the createContact input looks like this:

 user: String
 email: String!
 familyName: String
 givenName: String
 displayName: String
 clientMutationId: String

Answer 1

You have a couple of options here, depending on the amount of concurrency you want:

1. These should be performed in Serial

The client can make a single HTTP request with multiple mutations as aliases:

mutation CreateUsers {
  user1: createUser({ //userInput1 }) { ...userFields }
  user2: createUser({ //userInput2 }) { ...userFields }
  user3: createUser({ //userInput3 }) { ...userFields }
}

fragment userFields on CreateUserPayload {
  firstName
  // etc
}

The response will look like this:

{
  "data": {
    "user1": {...},
    "user2": {...},
    "user3": {...},
  }
}

Pros:

• If any single mutation fails, just that one will error out without special handling
• Order is maintained. Because the API consumer is specifically labelling the mutations, they know which one has which results.

Cons:

• By design, multiple mutations run in Serial, where the first must complete fully before the next one is started. Because of this it's going to be a bit slower.
• The client has to add the fields themselves or use a fragment for each mutation (what I showed above)

2. These should be performed in Parallel

It is a common practice (as common as it can be, I guess) to create a "bulk mutation" that allows you to create multiple users.

mutation CreateUsers {
  createUsers([
    { //userInput1 },
    { //userInput2 },
    { //userInput3 }
  ]) {
    firstName
    // etc
  }
}

Pros:

• Runs in parallel, so it's faster
• The client doesn't have to do string interpolation to build the query. They just need the array of objects to pass in.

Cons:

• You have to build the logic yourself to be able to return nulls vs errors on your own.
• You have to build the logic to maintain order
• The client has to build logic to find their results in the response array if they care about order.

Answer 2

This is how I did it:

Create a custom type:

class CustomType extends InputObjectType implements TypeInterface
{
    public function __construct()
    {
        $config = [
            'name' => 'CustomType',
            'fields' => [
                'id_1' => Type::nonNull(Type::id()),
                'id_2' => Type::nonNull(Type::id()),
                'value' => Type::string(),
            ],
        ];
        parent::__construct($config);
    }

    public function getName(): string
    {
        return 'CustomType';
    }
}

Register CustomType in src/config/services.yaml

(...)
App\Type\Definition\CustomType:
    tags:
        - { name: api_platform.graphql.type }

Add custom mutation to entity, using CustomType argument as array:

/**
* @ApiResource(
* (...)
*     graphql={
*     "customMutation"={
*         "args"={
*             (...)
*             "customArgumentName"={"type"=[CustomType!]"}
*         }
*     }
*)

Then the new customMutation can be called with an array of arguments like this:

mutation myMutation($input: customMutationEntitynameInput!) {
    customMutationEntityname(input: $input) {
        otherEntity {
            id
        }
    }
}

And graphql variables:

{
    "input": {
        "customArgumentName": [
            {
                "id_1": 3,
                "id_2": 4
            },{
                "id_1": 4,
                "id_2": 4
            }
        ]
    }
}