@graphql-tools/executor 0.0.1-alpha-20221025014654-e3be5659

package/cjs/execution/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.responsePathAsArray = void 0;
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./collectFields.js"), exports);
+tslib_1.__exportStar(require("./execute.js"), exports);
+tslib_1.__exportStar(require("./mapAsyncIterator.js"), exports);
+tslib_1.__exportStar(require("./values.js"), exports);
+var Path_js_1 = require("graphql/jsutils/Path.js");
+Object.defineProperty(exports, "responsePathAsArray", { enumerable: true, get: function () { return Path_js_1.pathToArray; } });

package/cjs/execution/mapAsyncIterator.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapAsyncIterator = void 0;
+/**
+ * Given an AsyncIterable and a callback function, return an AsyncIterator
+ * which produces values mapped via calling the callback function.
+ */
+function mapAsyncIterator(iterable, callback) {
+    const iterator = iterable[Symbol.asyncIterator]();
+    async function mapResult(result) {
+        if (result.done) {
+            return result;
+        }
+        try {
+            return { value: await callback(result.value), done: false };
+        }
+        catch (error) {
+            /* c8 ignore start */
+            // FIXME: add test case
+            if (typeof iterator.return === 'function') {
+                try {
+                    await iterator.return();
+                }
+                catch (_e) {
+                    /* ignore error */
+                }
+            }
+            throw error;
+            /* c8 ignore stop */
+        }
+    }
+    return {
+        async next() {
+            return mapResult(await iterator.next());
+        },
+        async return() {
+            // If iterator.return() does not exist, then type R must be undefined.
+            return typeof iterator.return === 'function'
+                ? mapResult(await iterator.return())
+                : { value: undefined, done: true };
+        },
+        async throw(error) {
+            if (typeof iterator.throw === 'function') {
+                return mapResult(await iterator.throw(error));
+            }
+            throw error;
+        },
+        [Symbol.asyncIterator]() {
+            return this;
+        },
+    };
+}
+exports.mapAsyncIterator = mapAsyncIterator;

package/cjs/execution/subscribe.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSourceEventStream = exports.subscribe = void 0;
+const graphql_1 = require("graphql");
+const devAssert_js_1 = require("graphql/jsutils/devAssert.js");
+const inspect_js_1 = require("graphql/jsutils/inspect.js");
+const isAsyncIterable_js_1 = require("graphql/jsutils/isAsyncIterable.js");
+const Path_js_1 = require("graphql/jsutils/Path.js");
+const collectFields_js_1 = require("./collectFields.js");
+const execute_js_1 = require("./execute.js");
+const mapAsyncIterator_js_1 = require("./mapAsyncIterator.js");
+const values_js_1 = require("./values.js");
+/**
+ * Implements the "Subscribe" algorithm described in the GraphQL specification.
+ *
+ * Returns a Promise which resolves to either an AsyncIterator (if successful)
+ * or an ExecutionResult (error). The promise will be rejected if the schema or
+ * other arguments to this function are invalid, or if the resolved event stream
+ * is not an async iterable.
+ *
+ * If the client-provided arguments to this function do not result in a
+ * compliant subscription, a GraphQL Response (ExecutionResult) with
+ * descriptive errors and no data will be returned.
+ *
+ * If the source stream could not be created due to faulty subscription
+ * resolver logic or underlying systems, the promise will resolve to a single
+ * ExecutionResult containing `errors` and no `data`.
+ *
+ * If the operation succeeded, the promise resolves to an AsyncIterator, which
+ * yields a stream of ExecutionResults representing the response stream.
+ *
+ * Accepts either an object with named arguments, or individual arguments.
+ */
+async function subscribe(args) {
+    // Temporary for v15 to v16 migration. Remove in v17
+    (0, devAssert_js_1.devAssert)(arguments.length < 2, 'graphql@16 dropped long-deprecated support for positional arguments, please pass an object instead.');
+    const { schema, document, rootValue, contextValue, variableValues, operationName, fieldResolver, subscribeFieldResolver, } = args;
+    const resultOrStream = await createSourceEventStream(schema, document, rootValue, contextValue, variableValues, operationName, subscribeFieldResolver);
+    if (!(0, isAsyncIterable_js_1.isAsyncIterable)(resultOrStream)) {
+        return resultOrStream;
+    }
+    // For each payload yielded from a subscription, map it over the normal
+    // GraphQL `execute` function, with `payload` as the rootValue.
+    // This implements the "MapSourceToResponseEvent" algorithm described in
+    // the GraphQL specification. The `execute` function provides the
+    // "ExecuteSubscriptionEvent" algorithm, as it is nearly identical to the
+    // "ExecuteQuery" algorithm, for which `execute` is also used.
+    const mapSourceToResponse = (payload) => (0, execute_js_1.execute)({
+        schema,
+        document,
+        rootValue: payload,
+        contextValue,
+        variableValues,
+        operationName,
+        fieldResolver,
+    });
+    // Map every source value to a ExecutionResult value as described above.
+    return (0, mapAsyncIterator_js_1.mapAsyncIterator)(resultOrStream, mapSourceToResponse);
+}
+exports.subscribe = subscribe;
+/**
+ * Implements the "CreateSourceEventStream" algorithm described in the
+ * GraphQL specification, resolving the subscription source event stream.
+ *
+ * Returns a Promise which resolves to either an AsyncIterable (if successful)
+ * or an ExecutionResult (error). The promise will be rejected if the schema or
+ * other arguments to this function are invalid, or if the resolved event stream
+ * is not an async iterable.
+ *
+ * If the client-provided arguments to this function do not result in a
+ * compliant subscription, a GraphQL Response (ExecutionResult) with
+ * descriptive errors and no data will be returned.
+ *
+ * If the the source stream could not be created due to faulty subscription
+ * resolver logic or underlying systems, the promise will resolve to a single
+ * ExecutionResult containing `errors` and no `data`.
+ *
+ * If the operation succeeded, the promise resolves to the AsyncIterable for the
+ * event stream returned by the resolver.
+ *
+ * A Source Event Stream represents a sequence of events, each of which triggers
+ * a GraphQL execution for that event.
+ *
+ * This may be useful when hosting the stateful subscription service in a
+ * different process or machine than the stateless GraphQL execution engine,
+ * or otherwise separating these two steps. For more on this, see the
+ * "Supporting Subscriptions at Scale" information in the GraphQL specification.
+ */
+async function createSourceEventStream(schema, document, rootValue, contextValue, variableValues, operationName, subscribeFieldResolver) {
+    // If arguments are missing or incorrectly typed, this is an internal
+    // developer mistake which should throw an early error.
+    (0, execute_js_1.assertValidExecutionArguments)(schema, document, variableValues);
+    // If a valid execution context cannot be created due to incorrect arguments,
+    // a "Response" with only errors is returned.
+    const exeContext = (0, execute_js_1.buildExecutionContext)({
+        schema,
+        document,
+        rootValue,
+        contextValue,
+        variableValues,
+        operationName,
+        subscribeFieldResolver,
+    });
+    // Return early errors if execution context failed.
+    if (!('schema' in exeContext)) {
+        return { errors: exeContext };
+    }
+    try {
+        const eventStream = await executeSubscription(exeContext);
+        // Assert field returned an event stream, otherwise yield an error.
+        if (!(0, isAsyncIterable_js_1.isAsyncIterable)(eventStream)) {
+            throw new Error('Subscription field must return Async Iterable. ' + `Received: ${(0, inspect_js_1.inspect)(eventStream)}.`);
+        }
+        return eventStream;
+    }
+    catch (error) {
+        // If it GraphQLError, report it as an ExecutionResult, containing only errors and no data.
+        // Otherwise treat the error as a system-class error and re-throw it.
+        if (error instanceof graphql_1.GraphQLError) {
+            return { errors: [error] };
+        }
+        throw error;
+    }
+}
+exports.createSourceEventStream = createSourceEventStream;
+async function executeSubscription(exeContext) {
+    var _a;
+    const { schema, fragments, operation, variableValues, rootValue } = exeContext;
+    const rootType = schema.getSubscriptionType();
+    if (rootType == null) {
+        throw new graphql_1.GraphQLError('Schema is not configured to execute subscription operation.', { nodes: operation });
+    }
+    const rootFields = (0, collectFields_js_1.collectFields)(schema, fragments, variableValues, rootType, operation.selectionSet);
+    const [responseName, fieldNodes] = [...rootFields.entries()][0];
+    const fieldDef = (0, execute_js_1.getFieldDef)(schema, rootType, fieldNodes[0]);
+    if (!fieldDef) {
+        const fieldName = fieldNodes[0].name.value;
+        throw new graphql_1.GraphQLError(`The subscription field "${fieldName}" is not defined.`, { nodes: fieldNodes });
+    }
+    const path = (0, Path_js_1.addPath)(undefined, responseName, rootType.name);
+    const info = (0, execute_js_1.buildResolveInfo)(exeContext, fieldDef, fieldNodes, rootType, path);
+    try {
+        // Implements the "ResolveFieldEventStream" algorithm from GraphQL specification.
+        // It differs from "ResolveFieldValue" due to providing a different `resolveFn`.
+        // Build a JS object of arguments from the field.arguments AST, using the
+        // variables scope to fulfill any variable references.
+        const args = (0, values_js_1.getArgumentValues)(fieldDef, fieldNodes[0], variableValues);
+        // The resolve function's optional third argument is a context value that
+        // is provided to every resolve function within an execution. It is commonly
+        // used to represent an authenticated user, or request-specific caches.
+        const contextValue = exeContext.contextValue;
+        // Call the `subscribe()` resolver or the default resolver to produce an
+        // AsyncIterable yielding raw payloads.
+        const resolveFn = (_a = fieldDef.subscribe) !== null && _a !== void 0 ? _a : exeContext.subscribeFieldResolver;
+        const eventStream = await resolveFn(rootValue, args, contextValue, info);
+        if (eventStream instanceof Error) {
+            throw eventStream;
+        }
+        return eventStream;
+    }
+    catch (error) {
+        throw (0, graphql_1.locatedError)(error, fieldNodes, (0, Path_js_1.pathToArray)(path));
+    }
+}

package/cjs/execution/values.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDirectiveValues = exports.getArgumentValues = exports.getVariableValues = void 0;
+const inspect_js_1 = require("graphql/jsutils/inspect.js");
+const keyMap_js_1 = require("graphql/jsutils/keyMap.js");
+const printPathArray_js_1 = require("graphql/jsutils/printPathArray.js");
+const graphql_1 = require("graphql");
+/**
+ * Prepares an object map of variableValues of the correct type based on the
+ * provided variable definitions and arbitrary input. If the input cannot be
+ * parsed to match the variable definitions, a GraphQLError will be thrown.
+ *
+ * Note: The returned value is a plain Object with a prototype, since it is
+ * exposed to user code. Care should be taken to not pull values from the
+ * Object prototype.
+ */
+function getVariableValues(schema, varDefNodes, inputs, options) {
+    const errors = [];
+    const maxErrors = options === null || options === void 0 ? void 0 : options.maxErrors;
+    try {
+        const coerced = coerceVariableValues(schema, varDefNodes, inputs, error => {
+            if (maxErrors != null && errors.length >= maxErrors) {
+                throw new graphql_1.GraphQLError('Too many errors processing variables, error limit reached. Execution aborted.');
+            }
+            errors.push(error);
+        });
+        if (errors.length === 0) {
+            return { coerced };
+        }
+    }
+    catch (error) {
+        errors.push(error);
+    }
+    // @ts-expect-error - We know that errors is an array of GraphQLError.
+    return { errors };
+}
+exports.getVariableValues = getVariableValues;
+function coerceVariableValues(schema, varDefNodes, inputs, onError) {
+    const coercedValues = {};
+    for (const varDefNode of varDefNodes) {
+        const varName = varDefNode.variable.name.value;
+        const varType = (0, graphql_1.typeFromAST)(schema, varDefNode.type);
+        if (!(0, graphql_1.isInputType)(varType)) {
+            // Must use input types for variables. This should be caught during
+            // validation, however is checked again here for safety.
+            const varTypeStr = (0, graphql_1.print)(varDefNode.type);
+            onError(new graphql_1.GraphQLError(`Variable "$${varName}" expected value of type "${varTypeStr}" which cannot be used as an input type.`, { nodes: varDefNode.type }));
+            continue;
+        }
+        if (!hasOwnProperty(inputs, varName)) {
+            if (varDefNode.defaultValue) {
+                coercedValues[varName] = (0, graphql_1.valueFromAST)(varDefNode.defaultValue, varType);
+            }
+            else if ((0, graphql_1.isNonNullType)(varType)) {
+                const varTypeStr = (0, inspect_js_1.inspect)(varType);
+                onError(new graphql_1.GraphQLError(`Variable "$${varName}" of required type "${varTypeStr}" was not provided.`, {
+                    nodes: varDefNode,
+                }));
+            }
+            continue;
+        }
+        const value = inputs[varName];
+        if (value === null && (0, graphql_1.isNonNullType)(varType)) {
+            const varTypeStr = (0, inspect_js_1.inspect)(varType);
+            onError(new graphql_1.GraphQLError(`Variable "$${varName}" of non-null type "${varTypeStr}" must not be null.`, {
+                nodes: varDefNode,
+            }));
+            continue;
+        }
+        coercedValues[varName] = (0, graphql_1.coerceInputValue)(value, varType, (path, invalidValue, error) => {
+            let prefix = `Variable "$${varName}" got invalid value ` + (0, inspect_js_1.inspect)(invalidValue);
+            if (path.length > 0) {
+                prefix += ` at "${varName}${(0, printPathArray_js_1.printPathArray)(path)}"`;
+            }
+            onError(new graphql_1.GraphQLError(prefix + '; ' + error.message, {
+                nodes: varDefNode,
+                originalError: error.originalError,
+            }));
+        });
+    }
+    return coercedValues;
+}
+/**
+ * Prepares an object map of argument values given a list of argument
+ * definitions and list of argument AST nodes.
+ *
+ * Note: The returned value is a plain Object with a prototype, since it is
+ * exposed to user code. Care should be taken to not pull values from the
+ * Object prototype.
+ */
+function getArgumentValues(def, node, variableValues) {
+    var _a;
+    const coercedValues = {};
+    // FIXME: https://github.com/graphql/graphql-js/issues/2203
+    /* c8 ignore next */
+    const argumentNodes = (_a = node.arguments) !== null && _a !== void 0 ? _a : [];
+    const argNodeMap = (0, keyMap_js_1.keyMap)(argumentNodes, arg => arg.name.value);
+    for (const argDef of def.args) {
+        const name = argDef.name;
+        const argType = argDef.type;
+        const argumentNode = argNodeMap[name];
+        if (!argumentNode) {
+            if (argDef.defaultValue !== undefined) {
+                coercedValues[name] = argDef.defaultValue;
+            }
+            else if ((0, graphql_1.isNonNullType)(argType)) {
+                throw new graphql_1.GraphQLError(`Argument "${name}" of required type "${(0, inspect_js_1.inspect)(argType)}" ` + 'was not provided.', {
+                    nodes: node,
+                });
+            }
+            continue;
+        }
+        const valueNode = argumentNode.value;
+        let isNull = valueNode.kind === graphql_1.Kind.NULL;
+        if (valueNode.kind === graphql_1.Kind.VARIABLE) {
+            const variableName = valueNode.name.value;
+            if (variableValues == null || !hasOwnProperty(variableValues, variableName)) {
+                if (argDef.defaultValue !== undefined) {
+                    coercedValues[name] = argDef.defaultValue;
+                }
+                else if ((0, graphql_1.isNonNullType)(argType)) {
+                    throw new graphql_1.GraphQLError(`Argument "${name}" of required type "${(0, inspect_js_1.inspect)(argType)}" ` +
+                        `was provided the variable "$${variableName}" which was not provided a runtime value.`, { nodes: valueNode });
+                }
+                continue;
+            }
+            isNull = variableValues[variableName] == null;
+        }
+        if (isNull && (0, graphql_1.isNonNullType)(argType)) {
+            throw new graphql_1.GraphQLError(`Argument "${name}" of non-null type "${(0, inspect_js_1.inspect)(argType)}" ` + 'must not be null.', {
+                nodes: valueNode,
+            });
+        }
+        const coercedValue = (0, graphql_1.valueFromAST)(valueNode, argType, variableValues);
+        if (coercedValue === undefined) {
+            // Note: ValuesOfCorrectTypeRule validation should catch this before
+            // execution. This is a runtime check to ensure execution does not
+            // continue with an invalid argument value.
+            throw new graphql_1.GraphQLError(`Argument "${name}" has invalid value ${(0, graphql_1.print)(valueNode)}.`, { nodes: valueNode });
+        }
+        coercedValues[name] = coercedValue;
+    }
+    return coercedValues;
+}
+exports.getArgumentValues = getArgumentValues;
+/**
+ * Prepares an object map of argument values given a directive definition
+ * and a AST node which may contain directives. Optionally also accepts a map
+ * of variable values.
+ *
+ * If the directive does not exist on the node, returns undefined.
+ *
+ * Note: The returned value is a plain Object with a prototype, since it is
+ * exposed to user code. Care should be taken to not pull values from the
+ * Object prototype.
+ */
+function getDirectiveValues(directiveDef, node, variableValues) {
+    var _a;
+    const directiveNode = (_a = node.directives) === null || _a === void 0 ? void 0 : _a.find(directive => directive.name.value === directiveDef.name);
+    if (directiveNode) {
+        return getArgumentValues(directiveDef, directiveNode, variableValues);
+    }
+    return undefined;
+}
+exports.getDirectiveValues = getDirectiveValues;
+function hasOwnProperty(obj, prop) {
+    return Object.prototype.hasOwnProperty.call(obj, prop);
+}

package/cjs/index.js

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

package/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

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,109 @@
+import { Kind, isAbstractType, GraphQLIncludeDirective, GraphQLSkipDirective, typeFromAST, } from 'graphql';
+import { AccumulatorMap } from './AccumulatorMap.js';
+import { getDirectiveValues } from './values.js';
+/**
+ * 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();
+    collectFieldsImpl(schema, fragments, variableValues, runtimeType, selectionSet, fields, new Set());
+    return fields;
+}
+/**
+ * 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 function collectSubfields(schema, fragments, variableValues, returnType, fieldNodes) {
+    const subFieldNodes = new AccumulatorMap();
+    const visitedFragmentNames = new Set();
+    for (const node of fieldNodes) {
+        if (node.selectionSet) {
+            collectFieldsImpl(schema, fragments, variableValues, returnType, node.selectionSet, subFieldNodes, visitedFragmentNames);
+        }
+    }
+    return subFieldNodes;
+}
+function collectFieldsImpl(schema, fragments, variableValues, runtimeType, selectionSet, fields, 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;
+                }
+                collectFieldsImpl(schema, fragments, variableValues, runtimeType, selection.selectionSet, fields, visitedFragmentNames);
+                break;
+            }
+            case Kind.FRAGMENT_SPREAD: {
+                const fragName = selection.name.value;
+                if (visitedFragmentNames.has(fragName) || !shouldIncludeNode(variableValues, selection)) {
+                    continue;
+                }
+                visitedFragmentNames.add(fragName);
+                const fragment = fragments[fragName];
+                if (!fragment || !doesFragmentConditionMatch(schema, fragment, runtimeType)) {
+                    continue;
+                }
+                collectFieldsImpl(schema, fragments, variableValues, runtimeType, fragment.selectionSet, fields, visitedFragmentNames);
+                break;
+            }
+        }
+    }
+}
+/**
+ * Determines if a field should be included based on the `@include` and `@skip`
+ * directives, where `@skip` has higher precedence than `@include`.
+ */
+function shouldIncludeNode(variableValues, node) {
+    const skip = getDirectiveValues(GraphQLSkipDirective, node, variableValues);
+    if ((skip === null || skip === void 0 ? void 0 : skip['if']) === true) {
+        return false;
+    }
+    const include = getDirectiveValues(GraphQLIncludeDirective, node, variableValues);
+    if ((include === null || include === void 0 ? void 0 : include['if']) === false) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Determines if a fragment is applicable to the given type.
+ */
+function doesFragmentConditionMatch(schema, fragment, type) {
+    const typeConditionNode = fragment.typeCondition;
+    if (!typeConditionNode) {
+        return true;
+    }
+    const conditionalType = typeFromAST(schema, typeConditionNode);
+    if (conditionalType === type) {
+        return true;
+    }
+    if (isAbstractType(conditionalType)) {
+        return schema.isSubType(conditionalType, type);
+    }
+    return false;
+}
+/**
+ * Implements the logic to compute the key of a given field's entry
+ */
+function getFieldEntryKey(node) {
+    return node.alias ? node.alias.value : node.name.value;
+}