Mutation：修改与写入

Mutation 基础

Schema 定义

input CreatePostInput {
  title: String!
  content: String!
  tags: [String!]
  published: Boolean = false
}

input UpdatePostInput {
  title: String
  content: String
  tags: [String!]
  published: Boolean
}

type Mutation {
  createPost(input: CreatePostInput!): Post!
  updatePost(id: ID!, input: UpdatePostInput!): Post!
  deletePost(id: ID!): DeletePostResult!
  publishPost(id: ID!): Post!
}

客户端调用

mutation CreatePost($input: CreatePostInput!) {
  createPost(input: $input) {
    id
    title
    published
    createdAt
    author { name }
  }
}

# Variables:
# {
#   "input": {
#     "title": "Hello GraphQL",
#     "content": "...",
#     "tags": ["graphql", "api"]
#   }
# }

Resolver 实现

const resolvers = {
  Mutation: {
    createPost: async (
      _: unknown,
      { input }: { input: CreatePostInput },
      { db, user }: Context
    ) => {
      // 验证用户已登录
      if (!user) throw new AuthenticationError('Must be logged in');

      // 创建帖子
      const post = await db.posts.create({
        data: {
          ...input,
          authorId: user.id,
        },
      });
      return post;
    },

    deletePost: async (_, { id }, { db, user }) => {
      const post = await db.posts.findUnique({ where: { id } });
      if (!post) throw new UserInputError('Post not found');
      if (post.authorId !== user.id) throw new ForbiddenError('Not your post');

      await db.posts.delete({ where: { id } });
      return { success: true, id };
    },
  },
};

错误处理模式

方案一：GraphQL errors 数组（Apollo 默认）

{
  "data": { "createPost": null },
  "errors": [
    {
      "message": "Title cannot be empty",
      "locations": [{ "line": 2, "column": 3 }],
      "path": ["createPost"],
      "extensions": {
        "code": "BAD_USER_INPUT",
        "field": "title"
      }
    }
  ]
}

方案二：Union 错误类型（推荐）

type ValidationError {
  field: String!
  message: String!
}

type CreatePostSuccess {
  post: Post!
}

type CreatePostError {
  message: String!
  validationErrors: [ValidationError!]
}

# Mutation 返回 Union 类型
union CreatePostResult = CreatePostSuccess | CreatePostError

type Mutation {
  createPost(input: CreatePostInput!): CreatePostResult!
}

# 客户端查询
mutation {
  createPost(input: { title: "", content: "..." }) {
    __typename
    ... on CreatePostSuccess {
      post { id title }
    }
    ... on CreatePostError {
      message
      validationErrors { field message }
    }
  }
}

文件上传（multipart）

scalar Upload

type Mutation {
  uploadAvatar(file: Upload!, userId: ID!): User!
  uploadMultiple(files: [Upload!]!): [File!]!
}

import { GraphQLUpload, FileUpload } from 'graphql-upload';

const resolvers = {
  Upload: GraphQLUpload,
  Mutation: {
    uploadAvatar: async (_, { file, userId }, { db, storage }) => {
      const { createReadStream, filename, mimetype }: FileUpload = await file;

      // 上传到对象存储（S3/OSS）
      const url = await storage.upload({
        stream: createReadStream(),
        key: `avatars/${userId}/${filename}`,
        contentType: mimetype,
      });

      return db.users.update({
        where: { id: userId },
        data: { avatarUrl: url },
      });
    },
  },
};

input 类型设计最佳实践

两种错误处理方案对比

// Prisma 事务：多个写操作原子性执行
const resolvers = {
  Mutation: {
    transferCredits: async (_, { fromId, toId, amount }, { db }) => {
      // $transaction 确保两个操作要么全成功，要么全失败
      const [from, to] = await db.$transaction([
        // 扣减发送方积分
        db.users.update({
          where: { id: fromId },
          data: { credits: { decrement: amount } },
        }),
        // 增加接收方积分
        db.users.update({
          where: { id: toId },
          data: { credits: { increment: amount } },
        }),
      ]);

      // 检查发送方余额是否足够（事务后验证）
      if (from.credits < 0) {
        throw new GraphQLError('Insufficient credits', {
          extensions: { code: 'BAD_USER_INPUT' }
        });
      }

      return { from, to, amount };
    },
  },
};