Day 3: Mutations: Writing Data | GraphQL in 5 Days

Mutations in the Schema

Schema additions

const typeDefs = `#graphql
  type Mutation {
    createUser(input: CreateUserInput!): User!
    updateUser(id: ID!, input: UpdateUserInput!): User!
    deleteUser(id: ID!): Boolean!
    createPost(input: CreatePostInput!): Post!
  }

  input CreateUserInput {
    name: String!
    email: String!
  }

  input UpdateUserInput {
    name: String
    email: String
  }

  input CreatePostInput {
    title: String!
    body: String
    authorId: ID!
  }
`

Mutation Resolvers

const resolvers = {
  Mutation: {
    createUser: (_, { input }) => {
      const user = { id: String(users.length + 1), ...input };
      users.push(user);
      return user;
    },
    updateUser: (_, { id, input }) => {
      const user = users.find(u => u.id === id);
      if (!user) throw new Error('User not found');
      Object.assign(user, input);
      return user;
    },
    deleteUser: (_, { id }) => {
      const idx = users.findIndex(u => u.id === id);
      if (idx === -1) return false;
      users.splice(idx, 1);
      return true;
    },
  }
};

Running a mutation

mutation CreateUser {
  createUser(input: {
    name: "Carol"
    email: "[email protected]"
  }) {
    id
    name
    email
  }
}

📝 Day 3 Exercise

Add Mutations to Your API

A
d
d
c
r
e
a
t
e
U
s
e
r
,
u
p
d
a
t
e
U
s
e
r
,
a
n
d
d
e
l
e
t
e
U
s
e
r
m
u
t
a
t
i
o
n
s
.
U
s
e
i
n
p
u
t
t
y
p
e
s
.
T
e
s
t
a
l
l
t
h
r
e
e
i
n
G
r
a
p
h
i
Q
L
.
A
d
d
b
a
s
i
c
v
a
l
i
d
a
t
i
o
n
(
t
h
r
o
w
a
n
e
r
r
o
r
i
f
e
m
a
i
l
a
l
r
e
a
d
y
e
x
i
s
t
s
)
.

Day 3 Summary

Mutations modify data. Same GraphQL format as queries but use the mutation keyword.
Input types group mutation arguments: input: CreateUserInput!.
Throw errors in resolvers for validation failures — GraphQL catches and returns them in the errors array.
The mutation response should include the created/updated object so the client can update its cache.

→

← Previous

Day 2: Queries: Fetching Exactly What You Need

Day 4: Authentication and Context

→