typescript - 如何在 Apollo Server 中将类型定义和解析器拆分为单独的文件

Question

索引.ts:

  const server = new ApolloServer({
    typeDefs,
    resolvers,
    context: ({ req, res }: any) => ({ req, res })
  });

用户架构.ts

export const typeDefs = gql`
  scalar TimeStamp
  type Query {
    getUser(id: Int!): User
  }
  type Mutation {
    addUser(
      name: String!
      email: String
      age: Int
      register_at: TimeStamp!
    ): Boolean!
  }
  type User {
    id: Int!
    name: String!
    email: String!
    age: Int!
    register_at: TimeStamp!
  }
`;

用户解析器.ts

export const resolvers = {
  TimeStamp: timeStamp,
  Query: {
    getUser: async (_: any, args: any) => {
      const { id } = args;

      return await User.findOne({ where: { id: id } });
    }
  },
  Mutation: {
    addUser: async (_: any, args: any) => {
      const { name, email, age, register_at } = args;
      try {
        const user = User.create({
          name,
          email,
          age,
          register_at
        });

        await user.save();

        return true;
      } catch (error) {
        return false;
      }
    }
  }
};

我想知道如果我有额外的类型定义和解析器，我将如何初始化我的 Apollo Server 实例，例如 BookSchema.ts和 BookResolver.ts .

Answer 1

类型定义
ApolloServer构造函数可以接受一个数组，而不仅仅是一个 DocumentNode目的。因此，您可以执行以下操作:

const server = new ApolloServer({
  typeDefs: [userTypeDefs, bookTypeDefs],
  resolvers,
})

请注意，如果您还想拆分单个类型的字段定义，则需要使用类型扩展语法。例如:

const typeDefsA = gql`
  type Query {
    users: [User!]!
  }
`
const typeDefsB = gql`
  extend type Query {
    books: [Book!]!
  }
`
const typeDefsC = gql`
  extend type Query {
    posts: [Post!]!
  }
`

以上将合并为一个 Query类型。您可以拥有任意数量的扩展名，但要扩展的类型 必须存在(即，您不能只有三个 extend type Query 定义)。牢记这一点，我通常会创建一组“基本”类型定义，例如:

type Query

type Mutation

然后我所有的其他类型定义都可以扩展这些类型。请注意，因为这些“基本”类型没有任何字段，所以我们根本不使用大括号(一组空的大括号将导致语法错误!)。

解析器

您的解析器映射是一个普通的 JavaScript 对象，因此将其拆分是微不足道的。

const resolversA = {
  Query: {
    users: () => {...},
  }
}

const resolversB = {
  Query: {
    books: () => {...},
  }
}

但是，如果您尝试使用 Object.assign 组合这些解析器映射，或传播语法，你会受到伤害，因为任何公共(public)属性(如 Query )将被每个对象覆盖。所以 不要做这个:

const resolvers = {
  ...resolversA,
  ...resolversB,
}

相反，您希望深度合并对象，以便合并所有子属性(及其属性等)。我推荐使用 lodash但是您可以使用任意数量的实用程序。

const resolvers = _.merge({}, resolversA, resolversB)

把它们放在一起

您的代码可能如下所示:

用户类型定义.ts

export default gql`
type User {
  id: ID!
  username: String!
  books: [Book!]!
}

extend type Query {
  users: [User!]!
}
`

bookTypeDefs.ts

export default gql`
type Book {
  id: ID!
  title: String!
  author: User!
}

extend type Query {
  books: [Book!]!
}
`

用户解析器.ts

export default {
  Query: {
    users: () => {...},
  },
  User: {
    books: () => {...},
  },
}

bookResolvers.ts

export default {
  Query: {
    books: () => {...},
  },
  Book: {
    author: () => {...},
  },
}

索引.ts

import userTypeDefs from '...'
import userResolvers from '...'
import bookTypeDefs from '...'
import bookResolvers from '...'

// Note: This is also a good place to put any types that are common to each "module"
const baseTypeDefs = gql`
  type Query
`

const apollo = new ApolloServer({
  typeDefs: [baseTypeDefs, userTypeDefs, bookTypeDefs],
  resolvers: _.merge({}, userResolvers, bookResolvers)
})