@graphql-tools/executor 0.0.1 → 0.0.2-alpha-20221029152711-14f4f7a7

package/cjs/directives/defer.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphQLDeferDirective = void 0;
+const graphql_1 = require("graphql");
+/**
+ * Used to conditionally defer fragments.
+ */
+exports.GraphQLDeferDirective = new graphql_1.GraphQLDirective({
+    name: 'defer',
+    description: 'Directs the executor to defer this fragment when the `if` argument is true or undefined.',
+    locations: [graphql_1.DirectiveLocation.FRAGMENT_SPREAD, graphql_1.DirectiveLocation.INLINE_FRAGMENT],
+    args: {
+        if: {
+            type: new graphql_1.GraphQLNonNull(graphql_1.GraphQLBoolean),
+            description: 'Deferred when true or undefined.',
+            defaultValue: true,
+        },
+        label: {
+            type: graphql_1.GraphQLString,
+            description: 'Unique name',
+        },
+    },
+});

package/cjs/directives/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./defer.js"), exports);
+tslib_1.__exportStar(require("./stream.js"), exports);

package/cjs/directives/stream.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphQLStreamDirective = void 0;
+const graphql_1 = require("graphql");
+/**
+ * Used to conditionally stream list fields.
+ */
+exports.GraphQLStreamDirective = new graphql_1.GraphQLDirective({
+    name: 'stream',
+    description: 'Directs the executor to stream plural fields when the `if` argument is true or undefined.',
+    locations: [graphql_1.DirectiveLocation.FIELD],
+    args: {
+        if: {
+            type: new graphql_1.GraphQLNonNull(graphql_1.GraphQLBoolean),
+            description: 'Stream when true or undefined.',
+            defaultValue: true,
+        },
+        label: {
+            type: graphql_1.GraphQLString,
+            description: 'Unique name',
+        },
+        initialCount: {
+            defaultValue: 0,
+            type: graphql_1.GraphQLInt,
+            description: 'Number of items to return immediately',
+        },
+    },
+});

package/cjs/execution/AccumulatorMap.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccumulatorMap = void 0;
+/**
+ * ES6 Map with additional `add` method to accumulate items.
+ */
+class AccumulatorMap extends Map {
+    get [Symbol.toStringTag]() {
+        return 'AccumulatorMap';
+    }
+    add(key, item) {
+        const group = this.get(key);
+        if (group === undefined) {
+            this.set(key, [item]);
+        }
+        else {
+            group.push(item);
+        }
+    }
+}
+exports.AccumulatorMap = AccumulatorMap;

package/cjs/execution/collectFields.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectSubfields = exports.collectFields = void 0;
+const graphql_1 = require("graphql");
+const utils_1 = require("@graphql-tools/utils");
+const AccumulatorMap_1 = require("./AccumulatorMap");
+const directives_1 = require("../directives");
+/**
+ * Given a selectionSet, collects all of the fields and returns them.
+ *
+ * CollectFields requires the "runtime type" of an object. For a field that
+ * returns an Interface or Union type, the "runtime type" will be the actual
+ * object type returned by that field.
+ *
+ * @internal
+ */
+function collectFields(schema, fragments, variableValues, runtimeType, selectionSet) {
+    const fields = new AccumulatorMap_1.AccumulatorMap();
+    const patches = [];
+    collectFieldsImpl(schema, fragments, variableValues, runtimeType, selectionSet, fields, patches, new Set());
+    return { fields, patches };
+}
+exports.collectFields = collectFields;
+/**
+ * Given an array of field nodes, collects all of the subfields of the passed
+ * in fields, and returns them at the end.
+ *
+ * CollectSubFields requires the "return type" of an object. For a field that
+ * returns an Interface or Union type, the "return type" will be the actual
+ * object type returned by that field.
+ *
+ * @internal
+ */
+exports.collectSubfields = (0, utils_1.memoize5)(function collectSubfields(schema, fragments, variableValues, returnType, fieldNodes) {
+    const subFieldNodes = new AccumulatorMap_1.AccumulatorMap();
+    const visitedFragmentNames = new Set();
+    const subPatches = [];
+    const subFieldsAndPatches = {
+        fields: subFieldNodes,
+        patches: subPatches,
+    };
+    for (const node of fieldNodes) {
+        if (node.selectionSet) {
+            collectFieldsImpl(schema, fragments, variableValues, returnType, node.selectionSet, subFieldNodes, subPatches, visitedFragmentNames);
+        }
+    }
+    return subFieldsAndPatches;
+});
+function collectFieldsImpl(schema, fragments, variableValues, runtimeType, selectionSet, fields, patches, visitedFragmentNames) {
+    for (const selection of selectionSet.selections) {
+        switch (selection.kind) {
+            case graphql_1.Kind.FIELD: {
+                if (!(0, utils_1.shouldIncludeNode)(variableValues, selection)) {
+                    continue;
+                }
+                fields.add((0, utils_1.getFieldEntryKey)(selection), selection);
+                break;
+            }
+            case graphql_1.Kind.INLINE_FRAGMENT: {
+                if (!(0, utils_1.shouldIncludeNode)(variableValues, selection) ||
+                    !(0, utils_1.doesFragmentConditionMatch)(schema, selection, runtimeType)) {
+                    continue;
+                }
+                const defer = getDeferValues(variableValues, selection);
+                if (defer) {
+                    const patchFields = new AccumulatorMap_1.AccumulatorMap();
+                    collectFieldsImpl(schema, fragments, variableValues, runtimeType, selection.selectionSet, patchFields, patches, visitedFragmentNames);
+                    patches.push({
+                        label: defer.label,
+                        fields: patchFields,
+                    });
+                }
+                else {
+                    collectFieldsImpl(schema, fragments, variableValues, runtimeType, selection.selectionSet, fields, patches, visitedFragmentNames);
+                }
+                break;
+            }
+            case graphql_1.Kind.FRAGMENT_SPREAD: {
+                const fragName = selection.name.value;
+                if (!(0, utils_1.shouldIncludeNode)(variableValues, selection)) {
+                    continue;
+                }
+                const defer = getDeferValues(variableValues, selection);
+                if (visitedFragmentNames.has(fragName) && !defer) {
+                    continue;
+                }
+                const fragment = fragments[fragName];
+                if (!fragment || !(0, utils_1.doesFragmentConditionMatch)(schema, fragment, runtimeType)) {
+                    continue;
+                }
+                if (!defer) {
+                    visitedFragmentNames.add(fragName);
+                }
+                if (defer) {
+                    const patchFields = new AccumulatorMap_1.AccumulatorMap();
+                    collectFieldsImpl(schema, fragments, variableValues, runtimeType, fragment.selectionSet, patchFields, patches, visitedFragmentNames);
+                    patches.push({
+                        label: defer.label,
+                        fields: patchFields,
+                    });
+                }
+                else {
+                    collectFieldsImpl(schema, fragments, variableValues, runtimeType, fragment.selectionSet, fields, patches, visitedFragmentNames);
+                }
+                break;
+            }
+        }
+    }
+}
+/**
+ * Returns an object containing the `@defer` arguments if a field should be
+ * deferred based on the experimental flag, defer directive present and
+ * not disabled by the "if" argument.
+ */
+function getDeferValues(variableValues, node) {
+    const defer = (0, graphql_1.getDirectiveValues)(directives_1.GraphQLDeferDirective, node, variableValues);
+    if (!defer) {
+        return;
+    }
+    if (defer['if'] === false) {
+        return;
+    }
+    return {
+        label: typeof defer['label'] === 'string' ? defer['label'] : undefined,
+    };
+}