@graphql-tools/delegate 9.0.0-alpha-e2ab84c8.0 → 9.0.0-alpha-25204a2f.0

package/cjs/finalizeGatewayRequest.js

@@ -0,0 +1,317 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.finalizeGatewayRequest = void 0;
+const graphql_1 = require("graphql");
+const utils_1 = require("@graphql-tools/utils");
+const getDocumentMetadata_js_1 = require("./getDocumentMetadata.js");
+function finalizeGatewayDocument(targetSchema, fragments, operations) {
+    var _a;
+    let usedVariables = [];
+    let usedFragments = [];
+    const newOperations = [];
+    let newFragments = [];
+    const validFragments = [];
+    const validFragmentsWithType = Object.create(null);
+    for (const fragment of fragments) {
+        const typeName = fragment.typeCondition.name.value;
+        const type = targetSchema.getType(typeName);
+        if (type != null) {
+            validFragments.push(fragment);
+            validFragmentsWithType[fragment.name.value] = type;
+        }
+    }
+    let fragmentSet = Object.create(null);
+    for (const operation of operations) {
+        const type = (0, utils_1.getDefinedRootType)(targetSchema, operation.operation);
+        const { selectionSet, usedFragments: operationUsedFragments, usedVariables: operationUsedVariables, } = finalizeSelectionSet(targetSchema, type, validFragmentsWithType, operation.selectionSet);
+        usedFragments = union(usedFragments, operationUsedFragments);
+        const { usedVariables: collectedUsedVariables, newFragments: collectedNewFragments, fragmentSet: collectedFragmentSet, } = collectFragmentVariables(targetSchema, fragmentSet, validFragments, validFragmentsWithType, usedFragments);
+        const operationOrFragmentVariables = union(operationUsedVariables, collectedUsedVariables);
+        usedVariables = union(usedVariables, operationOrFragmentVariables);
+        newFragments = collectedNewFragments;
+        fragmentSet = collectedFragmentSet;
+        const variableDefinitions = ((_a = operation.variableDefinitions) !== null && _a !== void 0 ? _a : []).filter((variable) => operationOrFragmentVariables.indexOf(variable.variable.name.value) !== -1);
+        newOperations.push({
+            kind: graphql_1.Kind.OPERATION_DEFINITION,
+            operation: operation.operation,
+            name: operation.name,
+            directives: operation.directives,
+            variableDefinitions,
+            selectionSet,
+        });
+    }
+    const newDocument = {
+        kind: graphql_1.Kind.DOCUMENT,
+        definitions: [...newOperations, ...newFragments],
+    };
+    return {
+        usedVariables,
+        newDocument,
+    };
+}
+function finalizeGatewayRequest(originalRequest, delegationContext) {
+    let { document, variables } = originalRequest;
+    let { operations, fragments } = (0, getDocumentMetadata_js_1.getDocumentMetadata)(document);
+    const { targetSchema, args } = delegationContext;
+    if (args) {
+        const requestWithNewVariables = addVariablesToRootFields(targetSchema, operations, args);
+        operations = requestWithNewVariables.newOperations;
+        variables = Object.assign({}, variables !== null && variables !== void 0 ? variables : {}, requestWithNewVariables.newVariables);
+    }
+    const { usedVariables, newDocument } = finalizeGatewayDocument(targetSchema, fragments, operations);
+    const newVariables = {};
+    if (variables != null) {
+        for (const variableName of usedVariables) {
+            const variableValue = variables[variableName];
+            if (variableValue !== undefined) {
+                newVariables[variableName] = variableValue;
+            }
+        }
+    }
+    return {
+        ...originalRequest,
+        document: newDocument,
+        variables: newVariables,
+    };
+}
+exports.finalizeGatewayRequest = finalizeGatewayRequest;
+function addVariablesToRootFields(targetSchema, operations, args) {
+    const newVariables = Object.create(null);
+    const newOperations = operations.map((operation) => {
+        var _a, _b;
+        const variableDefinitionMap = ((_a = operation.variableDefinitions) !== null && _a !== void 0 ? _a : []).reduce((prev, def) => ({
+            ...prev,
+            [def.variable.name.value]: def,
+        }), {});
+        const type = (0, utils_1.getDefinedRootType)(targetSchema, operation.operation);
+        const newSelections = [];
+        for (const selection of operation.selectionSet.selections) {
+            if (selection.kind === graphql_1.Kind.FIELD) {
+                const argumentNodes = (_b = selection.arguments) !== null && _b !== void 0 ? _b : [];
+                const argumentNodeMap = argumentNodes.reduce((prev, argument) => ({
+                    ...prev,
+                    [argument.name.value]: argument,
+                }), {});
+                const targetField = type.getFields()[selection.name.value];
+                // excludes __typename
+                if (targetField != null) {
+                    updateArguments(targetField, argumentNodeMap, variableDefinitionMap, newVariables, args);
+                }
+                newSelections.push({
+                    ...selection,
+                    arguments: Object.values(argumentNodeMap),
+                });
+            }
+            else {
+                newSelections.push(selection);
+            }
+        }
+        const newSelectionSet = {
+            kind: graphql_1.Kind.SELECTION_SET,
+            selections: newSelections,
+        };
+        return {
+            ...operation,
+            variableDefinitions: Object.values(variableDefinitionMap),
+            selectionSet: newSelectionSet,
+        };
+    });
+    return {
+        newOperations,
+        newVariables,
+    };
+}
+function updateArguments(targetField, argumentNodeMap, variableDefinitionMap, variableValues, newArgs) {
+    const generateVariableName = (0, utils_1.createVariableNameGenerator)(variableDefinitionMap);
+    for (const argument of targetField.args) {
+        const argName = argument.name;
+        const argType = argument.type;
+        if (argName in newArgs) {
+            (0, utils_1.updateArgument)(argumentNodeMap, variableDefinitionMap, variableValues, argName, generateVariableName(argName), argType, (0, utils_1.serializeInputValue)(argType, newArgs[argName]));
+        }
+    }
+}
+function collectFragmentVariables(targetSchema, fragmentSet, validFragments, validFragmentsWithType, usedFragments) {
+    let remainingFragments = usedFragments.slice();
+    let usedVariables = [];
+    const newFragments = [];
+    while (remainingFragments.length !== 0) {
+        const nextFragmentName = remainingFragments.pop();
+        const fragment = validFragments.find(fr => fr.name.value === nextFragmentName);
+        if (fragment != null) {
+            const name = nextFragmentName;
+            const typeName = fragment.typeCondition.name.value;
+            const type = targetSchema.getType(typeName);
+            if (type == null) {
+                throw new Error(`Fragment reference type "${typeName}", but the type is not contained within the target schema.`);
+            }
+            const { selectionSet, usedFragments: fragmentUsedFragments, usedVariables: fragmentUsedVariables, } = finalizeSelectionSet(targetSchema, type, validFragmentsWithType, fragment.selectionSet);
+            remainingFragments = union(remainingFragments, fragmentUsedFragments);
+            usedVariables = union(usedVariables, fragmentUsedVariables);
+            if (name && !(name in fragmentSet)) {
+                fragmentSet[name] = true;
+                newFragments.push({
+                    kind: graphql_1.Kind.FRAGMENT_DEFINITION,
+                    name: {
+                        kind: graphql_1.Kind.NAME,
+                        value: name,
+                    },
+                    typeCondition: fragment.typeCondition,
+                    selectionSet,
+                });
+            }
+        }
+    }
+    return {
+        usedVariables,
+        newFragments,
+        fragmentSet,
+    };
+}
+const filteredSelectionSetVisitorKeys = {
+    SelectionSet: ['selections'],
+    Field: ['selectionSet'],
+    InlineFragment: ['selectionSet'],
+    FragmentDefinition: ['selectionSet'],
+};
+const variablesVisitorKeys = {
+    SelectionSet: ['selections'],
+    Field: ['arguments', 'directives', 'selectionSet'],
+    Argument: ['value'],
+    InlineFragment: ['directives', 'selectionSet'],
+    FragmentSpread: ['directives'],
+    FragmentDefinition: ['selectionSet'],
+    ObjectValue: ['fields'],
+    ObjectField: ['name', 'value'],
+    Directive: ['arguments'],
+    ListValue: ['values'],
+};
+function finalizeSelectionSet(schema, type, validFragments, selectionSet) {
+    const usedFragments = [];
+    const usedVariables = [];
+    const typeInfo = graphql_1.versionInfo.major < 16 ? new graphql_1.TypeInfo(schema, undefined, type) : new graphql_1.TypeInfo(schema, type);
+    const filteredSelectionSet = (0, graphql_1.visit)(selectionSet, (0, graphql_1.visitWithTypeInfo)(typeInfo, {
+        [graphql_1.Kind.FIELD]: {
+            enter: node => {
+                const parentType = typeInfo.getParentType();
+                if ((0, graphql_1.isObjectType)(parentType) || (0, graphql_1.isInterfaceType)(parentType)) {
+                    const fields = parentType.getFields();
+                    const field = node.name.value === '__typename' ? graphql_1.TypeNameMetaFieldDef : fields[node.name.value];
+                    if (!field) {
+                        return null;
+                    }
+                    const args = field.args != null ? field.args : [];
+                    const argsMap = Object.create(null);
+                    for (const arg of args) {
+                        argsMap[arg.name] = arg;
+                    }
+                    if (node.arguments != null) {
+                        const newArgs = [];
+                        for (const arg of node.arguments) {
+                            if (arg.name.value in argsMap) {
+                                newArgs.push(arg);
+                            }
+                        }
+                        if (newArgs.length !== node.arguments.length) {
+                            return {
+                                ...node,
+                                arguments: newArgs,
+                            };
+                        }
+                    }
+                }
+            },
+            leave: node => {
+                const type = typeInfo.getType();
+                if (type == null) {
+                    throw new Error(`No type was found for field node ${(0, utils_1.inspect)(node)}.`);
+                }
+                const namedType = (0, graphql_1.getNamedType)(type);
+                if (!schema.getType(namedType.name) == null) {
+                    return null;
+                }
+                if ((0, graphql_1.isObjectType)(namedType) || (0, graphql_1.isInterfaceType)(namedType)) {
+                    const selections = node.selectionSet != null ? node.selectionSet.selections : null;
+                    if (selections == null || selections.length === 0) {
+                        return null;
+                    }
+                }
+            },
+        },
+        [graphql_1.Kind.FRAGMENT_SPREAD]: {
+            enter: node => {
+                if (!(node.name.value in validFragments)) {
+                    return null;
+                }
+                const parentType = typeInfo.getParentType();
+                const innerType = validFragments[node.name.value];
+                if (!(0, utils_1.implementsAbstractType)(schema, parentType, innerType)) {
+                    return null;
+                }
+                usedFragments.push(node.name.value);
+            },
+        },
+        [graphql_1.Kind.INLINE_FRAGMENT]: {
+            enter: node => {
+                if (node.typeCondition != null) {
+                    const parentType = typeInfo.getParentType();
+                    const innerType = schema.getType(node.typeCondition.name.value);
+                    if (!(0, utils_1.implementsAbstractType)(schema, parentType, innerType)) {
+                        return null;
+                    }
+                }
+            },
+        },
+        [graphql_1.Kind.SELECTION_SET]: {
+            leave: node => {
+                const parentType = typeInfo.getParentType();
+                if (parentType != null && (0, graphql_1.isAbstractType)(parentType)) {
+                    const selections = node.selections.concat([
+                        {
+                            kind: graphql_1.Kind.FIELD,
+                            name: {
+                                kind: graphql_1.Kind.NAME,
+                                value: '__typename',
+                            },
+                        },
+                    ]);
+                    return {
+                        ...node,
+                        selections,
+                    };
+                }
+            },
+        },
+    }), 
+    // visitorKeys argument usage a la https://github.com/gatsbyjs/gatsby/blob/master/packages/gatsby-source-graphql/src/batching/merge-queries.js
+    // empty keys cannot be removed only because of typescript errors
+    // will hopefully be fixed in future version of graphql-js to be optional
+    filteredSelectionSetVisitorKeys);
+    (0, graphql_1.visit)(filteredSelectionSet, {
+        [graphql_1.Kind.VARIABLE]: variableNode => {
+            usedVariables.push(variableNode.name.value);
+        },
+    }, 
+    // visitorKeys argument usage a la https://github.com/gatsbyjs/gatsby/blob/master/packages/gatsby-source-graphql/src/batching/merge-queries.js
+    // empty keys cannot be removed only because of typescript errors
+    // will hopefully be fixed in future version of graphql-js to be optional
+    variablesVisitorKeys);
+    return {
+        selectionSet: filteredSelectionSet,
+        usedFragments,
+        usedVariables,
+    };
+}
+function union(...arrays) {
+    const cache = Object.create(null);
+    const result = [];
+    for (const array of arrays) {
+        for (const item of array) {
+            if (!(item in cache)) {
+                cache[item] = true;
+                result.push(item);
+            }
+        }
+    }
+    return result;
+}

package/cjs/getDocumentMetadata.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDocumentMetadata = void 0;
+const graphql_1 = require("graphql");
+function getDocumentMetadata(document) {
+    const operations = [];
+    const fragments = [];
+    const fragmentNames = new Set();
+    for (let i = 0; i < document.definitions.length; i++) {
+        const def = document.definitions[i];
+        if (def.kind === graphql_1.Kind.FRAGMENT_DEFINITION) {
+            fragments.push(def);
+            fragmentNames.add(def.name.value);
+        }
+        else if (def.kind === graphql_1.Kind.OPERATION_DEFINITION) {
+            operations.push(def);
+        }
+    }
+    return {
+        operations,
+        fragments,
+        fragmentNames,
+    };
+}
+exports.getDocumentMetadata = getDocumentMetadata;

package/cjs/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./Subschema.js"), exports);
+tslib_1.__exportStar(require("./Transformer.js"), exports);
+tslib_1.__exportStar(require("./applySchemaTransforms.js"), exports);
+tslib_1.__exportStar(require("./createRequest.js"), exports);
+tslib_1.__exportStar(require("./defaultMergedResolver.js"), exports);
+tslib_1.__exportStar(require("./delegateToSchema.js"), exports);
+tslib_1.__exportStar(require("./mergeFields.js"), exports);
+tslib_1.__exportStar(require("./resolveExternalValue.js"), exports);
+tslib_1.__exportStar(require("./subschemaConfig.js"), exports);
+tslib_1.__exportStar(require("./types.js"), exports);

package/cjs/mergeFields.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeFields = exports.getUnpathedErrors = exports.getSubschema = exports.annotateExternalObject = exports.isExternalObject = void 0;
+const graphql_1 = require("graphql");
+const utils_1 = require("@graphql-tools/utils");
+const symbols_js_1 = require("./symbols.js");
+function isExternalObject(data) {
+    return data[symbols_js_1.UNPATHED_ERRORS_SYMBOL] !== undefined;
+}
+exports.isExternalObject = isExternalObject;
+function annotateExternalObject(object, errors, subschema, subschemaMap) {
+    Object.defineProperties(object, {
+        [symbols_js_1.OBJECT_SUBSCHEMA_SYMBOL]: { value: subschema },
+        [symbols_js_1.FIELD_SUBSCHEMA_MAP_SYMBOL]: { value: subschemaMap },
+        [symbols_js_1.UNPATHED_ERRORS_SYMBOL]: { value: errors },
+    });
+    return object;
+}
+exports.annotateExternalObject = annotateExternalObject;
+function getSubschema(object, responseKey) {
+    var _a;
+    return (_a = object[symbols_js_1.FIELD_SUBSCHEMA_MAP_SYMBOL][responseKey]) !== null && _a !== void 0 ? _a : object[symbols_js_1.OBJECT_SUBSCHEMA_SYMBOL];
+}
+exports.getSubschema = getSubschema;
+function getUnpathedErrors(object) {
+    return object[symbols_js_1.UNPATHED_ERRORS_SYMBOL];
+}
+exports.getUnpathedErrors = getUnpathedErrors;
+const EMPTY_ARRAY = [];
+const EMPTY_OBJECT = Object.create(null);
+async function mergeFields(mergedTypeInfo, object, sourceSubschema, context, info) {
+    var _a;
+    const delegationMaps = mergedTypeInfo.delegationPlanBuilder(info.schema, sourceSubschema, info.variableValues != null && Object.keys(info.variableValues).length > 0 ? info.variableValues : EMPTY_OBJECT, info.fragments != null && Object.keys(info.fragments).length > 0 ? info.fragments : EMPTY_OBJECT, ((_a = info.fieldNodes) === null || _a === void 0 ? void 0 : _a.length) ? info.fieldNodes : EMPTY_ARRAY);
+    for (const delegationMap of delegationMaps) {
+        await executeDelegationStage(mergedTypeInfo, delegationMap, object, context, info);
+    }
+    return object;
+}
+exports.mergeFields = mergeFields;
+async function executeDelegationStage(mergedTypeInfo, delegationMap, object, context, info) {
+    const combinedErrors = object[symbols_js_1.UNPATHED_ERRORS_SYMBOL];
+    const path = (0, graphql_1.responsePathAsArray)(info.path);
+    const combinedFieldSubschemaMap = object[symbols_js_1.FIELD_SUBSCHEMA_MAP_SYMBOL];
+    await Promise.all([...delegationMap.entries()].map(async ([subschema, selectionSet]) => {
+        var _a;
+        const schema = subschema.transformedSchema || info.schema;
+        const type = schema.getType(object.__typename);
+        const resolver = mergedTypeInfo.resolvers.get(subschema);
+        if (resolver) {
+            let source;
+            try {
+                source = await resolver(object, context, info, subschema, selectionSet, undefined, type);
+            }
+            catch (error) {
+                source = error;
+            }
+            if (source instanceof Error || source == null) {
+                const fieldNodeResponseKeyMap = (0, utils_1.collectFields)(schema, EMPTY_OBJECT, EMPTY_OBJECT, type, selectionSet, new Map(), new Set());
+                const nullResult = {};
+                for (const [responseKey, fieldNodes] of fieldNodeResponseKeyMap) {
+                    const combinedPath = [...path, responseKey];
+                    if (source instanceof graphql_1.GraphQLError) {
+                        nullResult[responseKey] = (0, utils_1.relocatedError)(source, combinedPath);
+                    }
+                    else if (source instanceof Error) {
+                        nullResult[responseKey] = (0, graphql_1.locatedError)(source, fieldNodes, combinedPath);
+                    }
+                    else {
+                        nullResult[responseKey] = null;
+                    }
+                }
+                source = nullResult;
+            }
+            else {
+                if (source[symbols_js_1.UNPATHED_ERRORS_SYMBOL]) {
+                    combinedErrors.push(...source[symbols_js_1.UNPATHED_ERRORS_SYMBOL]);
+                }
+            }
+            const objectSubschema = source[symbols_js_1.OBJECT_SUBSCHEMA_SYMBOL];
+            const fieldSubschemaMap = source[symbols_js_1.FIELD_SUBSCHEMA_MAP_SYMBOL];
+            for (const responseKey in source) {
+                object[responseKey] = source[responseKey];
+                combinedFieldSubschemaMap[responseKey] = (_a = fieldSubschemaMap === null || fieldSubschemaMap === void 0 ? void 0 : fieldSubschemaMap[responseKey]) !== null && _a !== void 0 ? _a : objectSubschema;
+            }
+        }
+    }));
+}

package/cjs/package.json

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