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

package/cjs/execution/flattenAsyncIterable.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flattenAsyncIterable = void 0;
+/**
+ * Given an AsyncIterable of AsyncIterables, flatten all yielded results into a
+ * single AsyncIterable.
+ */
+function flattenAsyncIterable(iterable) {
+    // You might think this whole function could be replaced with
+    //
+    //    async function* flattenAsyncIterable(iterable) {
+    //      for await (const subIterator of iterable) {
+    //        yield* subIterator;
+    //      }
+    //    }
+    //
+    // but calling `.return()` on the iterator it returns won't interrupt the `for await`.
+    const topIterator = iterable[Symbol.asyncIterator]();
+    let currentNestedIterator;
+    let waitForCurrentNestedIterator;
+    let done = false;
+    async function next() {
+        if (done) {
+            return { value: undefined, done: true };
+        }
+        try {
+            if (!currentNestedIterator) {
+                // Somebody else is getting it already.
+                if (waitForCurrentNestedIterator) {
+                    await waitForCurrentNestedIterator;
+                    return await next();
+                }
+                // Nobody else is getting it. We should!
+                let resolve;
+                waitForCurrentNestedIterator = new Promise(r => {
+                    resolve = r;
+                });
+                const topIteratorResult = await topIterator.next();
+                if (topIteratorResult.done) {
+                    // Given that done only ever transitions from false to true,
+                    // require-atomic-updates is being unnecessarily cautious.
+                    done = true;
+                    return await next();
+                }
+                // eslint is making a reasonable point here, but we've explicitly protected
+                // ourself from the race condition by ensuring that only the single call
+                // that assigns to waitForCurrentNestedIterator is allowed to assign to
+                // currentNestedIterator or waitForCurrentNestedIterator.
+                currentNestedIterator = topIteratorResult.value[Symbol.asyncIterator]();
+                waitForCurrentNestedIterator = undefined;
+                resolve();
+                return await next();
+            }
+            const rememberCurrentNestedIterator = currentNestedIterator;
+            const nestedIteratorResult = await currentNestedIterator.next();
+            if (!nestedIteratorResult.done) {
+                return nestedIteratorResult;
+            }
+            // The nested iterator is done. If it's still the current one, make it not
+            // current. (If it's not the current one, somebody else has made us move on.)
+            if (currentNestedIterator === rememberCurrentNestedIterator) {
+                currentNestedIterator = undefined;
+            }
+            return await next();
+        }
+        catch (err) {
+            done = true;
+            throw err;
+        }
+    }
+    return {
+        next,
+        async return() {
+            var _a, _b;
+            done = true;
+            await Promise.all([(_a = currentNestedIterator === null || currentNestedIterator === void 0 ? void 0 : currentNestedIterator.return) === null || _a === void 0 ? void 0 : _a.call(currentNestedIterator), (_b = topIterator.return) === null || _b === void 0 ? void 0 : _b.call(topIterator)]);
+            return { value: undefined, done: true };
+        },
+        async throw(error) {
+            var _a, _b;
+            done = true;
+            await Promise.all([(_a = currentNestedIterator === null || currentNestedIterator === void 0 ? void 0 : currentNestedIterator.throw) === null || _a === void 0 ? void 0 : _a.call(currentNestedIterator, error), (_b = topIterator.throw) === null || _b === void 0 ? void 0 : _b.call(topIterator, error)]);
+            /* c8 ignore next */
+            throw error;
+        },
+        [Symbol.asyncIterator]() {
+            return this;
+        },
+    };
+}
+exports.flattenAsyncIterable = flattenAsyncIterable;

package/cjs/execution/invariant.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.invariant = void 0;
+function invariant(condition, message) {
+    if (!condition) {
+        throw new Error(message != null ? message : 'Unexpected invariant triggered.');
+    }
+}
+exports.invariant = invariant;

package/cjs/execution/promiseForObject.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promiseForObject = void 0;
+/**
+ * This function transforms a JS object `Record<string, Promise<T>>` into
+ * a `Promise<Record<string, T>>`
+ *
+ * This is akin to bluebird's `Promise.props`, but implemented only using
+ * `Promise.all` so it will work with any implementation of ES6 promises.
+ */
+async function promiseForObject(object) {
+    const keys = Object.keys(object);
+    const values = Object.values(object);
+    const resolvedValues = await Promise.all(values);
+    const resolvedObject = Object.create(null);
+    for (let i = 0; i < keys.length; ++i) {
+        resolvedObject[keys[i]] = resolvedValues[i];
+    }
+    return resolvedObject;
+}
+exports.promiseForObject = promiseForObject;

package/cjs/index.js

@@ -2,3 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./execution/index.js"), exports);
+tslib_1.__exportStar(require("./directives/index.js"), exports);

package/esm/directives/defer.js

@@ -0,0 +1,20 @@
+import { DirectiveLocation, GraphQLBoolean, GraphQLDirective, GraphQLNonNull, GraphQLString } from 'graphql';
+/**
+ * Used to conditionally defer fragments.
+ */
+export const GraphQLDeferDirective = new GraphQLDirective({
+    name: 'defer',
+    description: 'Directs the executor to defer this fragment when the `if` argument is true or undefined.',
+    locations: [DirectiveLocation.FRAGMENT_SPREAD, DirectiveLocation.INLINE_FRAGMENT],
+    args: {
+        if: {
+            type: new GraphQLNonNull(GraphQLBoolean),
+            description: 'Deferred when true or undefined.',
+            defaultValue: true,
+        },
+        label: {
+            type: GraphQLString,
+            description: 'Unique name',
+        },
+    },
+});

package/esm/directives/index.js

@@ -0,0 +1,2 @@
+export * from './defer.js';
+export * from './stream.js';

package/esm/directives/stream.js

@@ -0,0 +1,25 @@
+import { DirectiveLocation, GraphQLBoolean, GraphQLDirective, GraphQLInt, GraphQLNonNull, GraphQLString, } from 'graphql';
+/**
+ * Used to conditionally stream list fields.
+ */
+export const GraphQLStreamDirective = new GraphQLDirective({
+    name: 'stream',
+    description: 'Directs the executor to stream plural fields when the `if` argument is true or undefined.',
+    locations: [DirectiveLocation.FIELD],
+    args: {
+        if: {
+            type: new GraphQLNonNull(GraphQLBoolean),
+            description: 'Stream when true or undefined.',
+            defaultValue: true,
+        },
+        label: {
+            type: GraphQLString,
+            description: 'Unique name',
+        },
+        initialCount: {
+            defaultValue: 0,
+            type: GraphQLInt,
+            description: 'Number of items to return immediately',
+        },
+    },
+});

package/esm/execution/AccumulatorMap.js

@@ -0,0 +1,17 @@
+/**
+ * ES6 Map with additional `add` method to accumulate items.
+ */
+export 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);
+        }
+    }
+}

package/esm/execution/collectFields.js

@@ -0,0 +1,122 @@
+import { Kind, getDirectiveValues, } from 'graphql';
+import { doesFragmentConditionMatch, getFieldEntryKey, memoize5, shouldIncludeNode } from '@graphql-tools/utils';
+import { AccumulatorMap } from './AccumulatorMap';
+import { GraphQLDeferDirective } from '../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
+ */
+export function collectFields(schema, fragments, variableValues, runtimeType, selectionSet) {
+    const fields = new AccumulatorMap();
+    const patches = [];
+    collectFieldsImpl(schema, fragments, variableValues, runtimeType, selectionSet, fields, patches, new Set());
+    return { fields, patches };
+}
+/**
+ * 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
+ */
+export const collectSubfields = memoize5(function collectSubfields(schema, fragments, variableValues, returnType, fieldNodes) {
+    const subFieldNodes = new 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 Kind.FIELD: {
+                if (!shouldIncludeNode(variableValues, selection)) {
+                    continue;
+                }
+                fields.add(getFieldEntryKey(selection), selection);
+                break;
+            }
+            case Kind.INLINE_FRAGMENT: {
+                if (!shouldIncludeNode(variableValues, selection) ||
+                    !doesFragmentConditionMatch(schema, selection, runtimeType)) {
+                    continue;
+                }
+                const defer = getDeferValues(variableValues, selection);
+                if (defer) {
+                    const patchFields = new 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 Kind.FRAGMENT_SPREAD: {
+                const fragName = selection.name.value;
+                if (!shouldIncludeNode(variableValues, selection)) {
+                    continue;
+                }
+                const defer = getDeferValues(variableValues, selection);
+                if (visitedFragmentNames.has(fragName) && !defer) {
+                    continue;
+                }
+                const fragment = fragments[fragName];
+                if (!fragment || !doesFragmentConditionMatch(schema, fragment, runtimeType)) {
+                    continue;
+                }
+                if (!defer) {
+                    visitedFragmentNames.add(fragName);
+                }
+                if (defer) {
+                    const patchFields = new 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 = getDirectiveValues(GraphQLDeferDirective, node, variableValues);
+    if (!defer) {
+        return;
+    }
+    if (defer['if'] === false) {
+        return;
+    }
+    return {
+        label: typeof defer['label'] === 'string' ? defer['label'] : undefined,
+    };
+}