Apollo GraphQL：如何拥有使用递归的解析器？

Question

My database is modelled as a "forest," or a group of trees. There are top level nodes that can link to multiple nodes below it, each potentially linking to nodes below it.

I want to implement a resolver that finds a tree and deletes it. This means it has to find a top-level node, search for its children, delete them, and then search for their own children, and so on. I'm not sure how to implement this recursion with resolvers.

A recursive structure for this would look something like

function deleteNodes(rootID) {
    root = database.find(id: rootID);
    if (!root.childrenIDs) return;
    database.delete(id: rootID);
    root.childrenIDs.map((childId) => deleteNodes(childId));
}

But I'm not sure how this would work in a resolver, where my code structure looks like:

module.exports {
    Query: {...},
    Mutation: {
        deleteNodes: async (_, args) => {...}
    }
}

How could I design a helper function or recursively call a resolver, or if that's not permitted, how could I execute what I want? Not sure I can call the resolver directly inside the resolver itself.

Answer 1

The rule that I have that could help you here is that resolvers should have no business logic in them. I use apollo-server and DataSources , but before that I had a similar setup, where the context object has all of my business logic on it. In this way, the resolvers are "just routers", and you can replace GraphQL with REST + Express, or gRPC, or whatever you want.

I'm using the DataSources model here, but you could just have a set of "business logic helpers. I do all of this on context so I can inject them easier for testing.

That would mean that in this case, your resolver would look like this:

module.exports = {
  Query: {...},
  Mutation: {
    deleteNodes: async (_, args, context) => {
      const result = await context.dataSources.nodes.deleteNodes(args.id);
      // something to handle your result
      return whatever;
    }
  }
}

Separately, you would have some nodes dataSource:

const { DataSource } = require('apollo-datasource')

module.exports = class NodesDataSource extends DataSource {
  constructor() {
    this.database = something;
  }

  deleteNodes(rootID) {
    const root = await this.database.find(id: rootID);
    if (!root.childrenIDs) return;
    await this.database.delete(id: rootID);
    await Promise.all(root.childrenIDs.map((childId) => this.deleteNodes(childId)));
  }
}

and in your ApolloServer setup:

const NodesDataSource = require('./datasources/nodes-datasource');

const server = new ApolloServer({
  resolvers,
  typeDefs,
  dataSources: () => {
    return {
      nodes: new NodesDataSource(),
    };
  },
});