In this video, we're gonna be running another mutation, but

this time with a different set of arguments.

Instead of only specifying scalar arguments, like title and tag line,

this time were gonna add a more complex object type called an input object.

Unlike scalars, input objects have their own nested properties,

which can be scalars or more input objects.

The endpoint we're using in this video is the add director to movie endpoint.

To see which arguments the add director to movie endpoint accepts,

let's scroll down in our back end editor to check out the schema under type deps.

Looks like it takes a movie ID of type ID, which in this case just means a string.

It also takes a director object of type director input.

If we scroll up to check out the director input type,

we can see that the only field that it contains is the name field.

Going back to our addDirectorToMovie endpoint,

you can see that there's a colon after the arguments list.

This colon indicates what type of object will be returned from this mutation.

Just like the create movie endpoint,

addDirectorToMovie also returns a movie object.

To define the input object we're going to use the query variables pane in Launchpad,

right below the query editor pane.

This is pure JSON, so we just need to name the argument.

In this case, that will be directorToAdd.

Followed by a colon and curly braces.

Inside the curly braces, add the only required director property which is name.

I'm gonna go ahead and use my name for the value, but you can use your name or

any other name you see fit.

Now, let's write the mutation.

Since we are passing in a query variable, we need to let GraphQL know at the top

of our mutation declaration what type of variabless being passed in.

The way that we do this is after the mutation declaration,

we add parenthesis then we put in a dollar sign followed by the name of

the query variable we'll be using, which in this case is directorToAdd.

To let the endpoint know that this is actually the type of argument that it

requires, we need to specify that our query variable is of type director input.

And we'll go ahead and put an exclamation point to let them know that it's required.

Now for the addDirectorToMovie endpoint we can plug in the arguments.

For movieId, let's go ahead and

use movie_0, that should be the first movie in our list.

And then for director, we're just gonna go ahead and

reference that directorToAdd variable that we declared at the top.

Note that again we've included this dollar sign before the variable name.

That's how GraphQL knows that we're using these query variables.

Just like every other operation we've run,

we need to specify which field we want to appear on the response.

We know that addDirectorToMovie returns a movie, so this time around we'll

return the title, the tagline and the directors list.

This will be a list of the directors and

should include the director that we've just added.

As we know director is not a scalar type, instead it's an object type.

Therefore we need to specify which fields we'd

like to see in those nested directors.

In our case, we're going to look for the ID in the name fields.

Go ahead and click play.

There we go.

We can see our title, our tagline, and our directors list.

And as you can see, our new director Isaac Lee Morris, has been added to the list.

And that's it, you've learned how to use mutations with both scalar and

input object types, which will wrap-up this stage.

In the next stage,

I'll go over some tricks you can use to make using GraphQL even simpler.