GraphQL：几个字段解析器

Question

everyone!

Has anyone met such case in graphql: you need resolve several fields with several async sources like this?

type Entity {
  # ---- dataSource1
  fieldA: String
  fieldB: String
  # ---- dataSource2
  fieldC: String
  fieldD: Stirng
}

So fieldA and fieldB need to be resolved by dataSource1, and fieldC and fieldD - by dataSource2

I found 2 solutions, but it seem to be unnatural for graphql and looks like hack.

Does anyone knows more convinient way to solve it? Appreciate your help!

PS Fields need to be resolved on the same field level;

1st - is to check dataSource2 attributes in the query's AST and include its call or not:

Query: {
  Entity: async (_, args, context, info) => {
    const result = {};
    
    if (hasArrts(info, SOURCE_ONE_ARGS)) {
      const data = await dataSource1.load(args);
      Object.assign(result, data);
    }
    if (hasArrts(info, SOURCE_TWO_ARGS)) {
      const data = await dataSource2.load(args);
      Object.assign(result, data);
    }
    
    return result;
  }
}

2nd - is to manage it with graphql/dataloader like this (it is possible due to caching and promise scheduling in the dataloader)

Query: {
  Entity: {
    fieldA: async (_, args) => {
      const { fieldA } = await dataSource1.load(args);
    
      return fieldA;
    },
    fieldB: async (_, args) => {
      const { fieldB } = await dataSource1.load(args);
    
      return fieldB;
    },
    fieldC: async (_, args) => {
      const { fieldC } = await dataSource2.load(args);
      
      return fieldC;
    },
    fieldD: async (_, args) => {
      const { fieldD } = await dataSource2.load(args);
      
      return fieldD;
    },
  },
};

Answer 1

The "correct answer" (quotes here, because this is my opinion) is definitely number 2. One of the principles I teach with GraphQL is that you should never be doing work on the server that the client isn't SPECIFICALLY asking for. That means if the client is only ever asking for fields A & B, which come from DataSource1, you're doing all of the work to call DataSource2 for absolutely no reason.

Some extra points here:

1. Generally in cases like this, there is "one source of truth for the object", and "an extra service to get other properties". The source of truth will usually be called by the parent resolver to pull the object, and the "extra service" would be called only in the resolvers that needs the "extra lookup".

2. Some people take this to an extreme and ONLY use field-level resolvers .

3. If you do actually do what that blog post suggests, please be careful that you're not using a "dummy resolver" as the parent resolver like he does. It just returns { id: <id> } without actually calling the source of truth to ensure the object actually exists. This means that if the object doesn't actually exist , you would return an object with null properties instead of returning the null as the object (since it doesn't actually exist).

If you go with all of this, you can go two ways:

Check for existence only:

const resolver = {
  Query: {
    someEntity: async (_, args, context) => {
      // Super light-way check for existence without loading any fields
      const exists = dataSource1.exists(args.id);

      if (!exists) {
        return null;
      }
      return { id: args.id };
    },
  },
  Entity: {
    fieldA: async (_, args) => {
      const { fieldA } = await dataSource1.load(args);
    
      return fieldA;
    },
    fieldB: async (_, args) => {
      const { fieldB } = await dataSource1.load(args);
    
      return fieldB;
    },
    fieldC: async (_, args) => {
      const { fieldC } = await dataSource2.load(args);
      
      return fieldC;
    },
    fieldD: async (_, args) => {
      const { fieldD } = await dataSource2.load(args);
      
      return fieldD;
    },
  },
};

Load from source of truth first:

const resolver = {
  Query: {
    someEntity: async (_, args, context) => {
      return datasource1.load(args.id);
    },
  },
  Entity: {
    fieldC: async (_, args) => {
      const { fieldC } = await dataSource2.load(args);
      
      return fieldC;
    },
    fieldD: async (_, args) => {
      const { fieldD } = await dataSource2.load(args);
      
      return fieldD;
    },
  },
};