Question

我可能面临Apollo GraphQL server的设计限制，我想询问是否有解决方法。

我的架构包含Thing类型，其中包含字段flag。我希望能够按things的值过滤flag，但如果单独解析此字段，则似乎无法进行。如果我想对things进行排序，会出现同样的问题。这是一个例子：

  type Thing {
    id: String!
    flag Boolean!
  }

  type Query {
    things(onlyWhereFlagIsTrue: Boolean): [Thing!]!
  }

const resolvers = {
  Thing: {
    flag: async ({id}) => {
      const value = await getFlagForThing(id);
      return value;
    }
  },
  Query: {
    async things(obj, {onlyWhereFlagIsTrue = false}) {
      let result = await getThingsWithoutFlags();
      if (onlyWhereFlagIsTrue) {
        // ↓ this does not work, because flag is still undefined
        result = _.filter(result, ['flag', true]);
      }
      return result;
    }
  }
}

在解决了所有异步字段后，有没有办法过滤things？我知道我可以在getFlagForThing(id)解析器内拨打things，但这不会重复我自己吗？解析flag背后的逻辑可能比调用一个函数更复杂。

UPD：这是迄今为止我能找到的最佳解决方案。非常丑陋，难以扩展到其他领域：

const resolvers = {
  Thing: {
    flag: async ({id, flag}) => {
      // need to check if flag has already been resolved
      // to avoid calling getThingsWithoutFlags() twice
      if (!_.isUndefined(flag)) {
        return flag;
      }
      const value = await getFlagForThing(id);
      return value;
    }
  },
  Query: {
    async things(obj, {onlyWhereFlagIsTrue = false}) {
      let result = await getThingsWithoutFlags();
      if (onlyWhereFlagIsTrue) {
        // asynchroniously resolving flags when needed
        const promises = _.map(result, ({id}) =>
          getFlagForThing(id)
        );
        const flags = await Promise.all(promises);
        for (let i = 0; i < flags.length; i += 1) {
          result[i].flag = flags[i];
        }
        // ↓ this line works now
        result = _.filter(result, ['flag', true]);
      }
      return result;
    }
  },
};

Answer 1

我认为这里的问题实际上并不是Apollo服务器的局限性，更多与您拥有带有解析程序的原始字段有关。通常，最好仅在该字段将返回单独的类型时才对字段使用解析器：

Thing {
    id: ID!
    flag: Boolean!
    otherThings: OtherThing
}

Query {
    things(onlyWhereFlag: Boolean): [Thing!]!
}

在此示例中，可以为otherThings设置一个单独的解析器，但是如果某个字段是原始字段，那么我将与Thing一起解析该字段。使用原始架构：

const filterByKeyValuePair = ([key, value]) => obj => obj[key] === value;

const resolvers = {
    Query: {
        async things(parent, { onlyWhereFlag }) {
            const things = await Promise.all(
                (await getThings()).map(
                    thing =>
                        new Promise(async resolve =>
                            resolve({
                                ...thing,
                                flag: await getFlagForThing(thing)
                            })
                        )
                )
            );

            if (onlyWhereFlag) {
                return things.filter(filterByKeyValuePair(['flag', true]));
            } else {
                return things;
            }
        }
    }
};

如果flag不是原始元素怎么办？好吧，如果您想按它进行筛选，那么您将有两个不同的选择。这些选项实际上取决于您如何获取“标志”数据。如果您可以提供有关架构和数据模型的更多详细信息，我很乐意详细说明。

Apollo GraphQL服务器：由单独解析的字段过滤（或排序）

1 个答案: