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

package/README.md

@@ -3,5 +3,3 @@ https://www.graphql-tools.com/docs/api/modules/delegate_src
 
 You can also learn more about Schema Delegation in this chapter;
 https://www.graphql-tools.com/docs/schema-delegation
-
-

package/cjs/Subschema.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Subschema = exports.isSubschema = void 0;
+const applySchemaTransforms_js_1 = require("./applySchemaTransforms.js");
+function isSubschema(value) {
+    return Boolean(value.transformedSchema);
+}
+exports.isSubschema = isSubschema;
+class Subschema {
+    constructor(config) {
+        var _a;
+        this.schema = config.schema;
+        this.executor = config.executor;
+        this.batch = config.batch;
+        this.batchingOptions = config.batchingOptions;
+        this.createProxyingResolver = config.createProxyingResolver;
+        this.transforms = (_a = config.transforms) !== null && _a !== void 0 ? _a : [];
+        this.transformedSchema = (0, applySchemaTransforms_js_1.applySchemaTransforms)(this.schema, config);
+        this.merge = config.merge;
+    }
+}
+exports.Subschema = Subschema;

package/cjs/Transformer.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Transformer = void 0;
+const prepareGatewayDocument_js_1 = require("./prepareGatewayDocument.js");
+const finalizeGatewayRequest_js_1 = require("./finalizeGatewayRequest.js");
+const checkResultAndHandleErrors_js_1 = require("./checkResultAndHandleErrors.js");
+class Transformer {
+    constructor(context) {
+        this.transformations = [];
+        this.delegationContext = context;
+        const transforms = context.transforms;
+        const delegationTransforms = transforms.slice().reverse();
+        for (const transform of delegationTransforms) {
+            this.addTransform(transform, {});
+        }
+    }
+    addTransform(transform, context = {}) {
+        this.transformations.push({ transform, context });
+    }
+    transformRequest(originalRequest) {
+        var _a;
+        let request = {
+            ...originalRequest,
+            document: (0, prepareGatewayDocument_js_1.prepareGatewayDocument)(originalRequest.document, this.delegationContext.transformedSchema, this.delegationContext.returnType, (_a = this.delegationContext.info) === null || _a === void 0 ? void 0 : _a.schema),
+        };
+        for (const transformation of this.transformations) {
+            if (transformation.transform.transformRequest) {
+                request = transformation.transform.transformRequest(request, this.delegationContext, transformation.context);
+            }
+        }
+        return (0, finalizeGatewayRequest_js_1.finalizeGatewayRequest)(request, this.delegationContext);
+    }
+    transformResult(originalResult) {
+        let result = originalResult;
+        // from right to left
+        for (let i = this.transformations.length - 1; i >= 0; i--) {
+            const transformation = this.transformations[i];
+            if (transformation.transform.transformResult) {
+                result = transformation.transform.transformResult(result, this.delegationContext, transformation.context);
+            }
+        }
+        return (0, checkResultAndHandleErrors_js_1.checkResultAndHandleErrors)(result, this.delegationContext);
+    }
+}
+exports.Transformer = Transformer;

package/cjs/applySchemaTransforms.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applySchemaTransforms = void 0;
+function applySchemaTransforms(originalWrappingSchema, subschemaConfig) {
+    const schemaTransforms = subschemaConfig.transforms;
+    if (schemaTransforms == null) {
+        return originalWrappingSchema;
+    }
+    return schemaTransforms.reduce((schema, transform) => transform.transformSchema != null ? transform.transformSchema(schema, subschemaConfig) : schema, originalWrappingSchema);
+}
+exports.applySchemaTransforms = applySchemaTransforms;

package/cjs/checkResultAndHandleErrors.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeDataAndErrors = exports.checkResultAndHandleErrors = void 0;
+const graphql_1 = require("graphql");
+const utils_1 = require("@graphql-tools/utils");
+const resolveExternalValue_js_1 = require("./resolveExternalValue.js");
+function checkResultAndHandleErrors(result, delegationContext) {
+    const { context, info, fieldName: responseKey = getResponseKey(info), subschema, returnType = getReturnType(info), skipTypeMerging, onLocatedError, } = delegationContext;
+    const { data, unpathedErrors } = mergeDataAndErrors(result.data == null ? undefined : result.data[responseKey], result.errors == null ? [] : result.errors, info != null && info.path ? (0, graphql_1.responsePathAsArray)(info.path) : undefined, onLocatedError);
+    return (0, resolveExternalValue_js_1.resolveExternalValue)(data, unpathedErrors, subschema, context, info, returnType, skipTypeMerging);
+}
+exports.checkResultAndHandleErrors = checkResultAndHandleErrors;
+function mergeDataAndErrors(data, errors, path, onLocatedError, index = 1) {
+    var _a;
+    if (data == null) {
+        if (!errors.length) {
+            return { data: null, unpathedErrors: [] };
+        }
+        if (errors.length === 1) {
+            const error = onLocatedError ? onLocatedError(errors[0]) : errors[0];
+            const newPath = path === undefined ? error.path : !error.path ? path : path.concat(error.path.slice(1));
+            return { data: (0, utils_1.relocatedError)(errors[0], newPath), unpathedErrors: [] };
+        }
+        // We cast path as any for GraphQL.js 14 compat
+        // locatedError path argument must be defined, but it is just forwarded to a constructor that allows a undefined value
+        // https://github.com/graphql/graphql-js/blob/b4bff0ba9c15c9d7245dd68556e754c41f263289/src/error/locatedError.js#L25
+        // https://github.com/graphql/graphql-js/blob/b4bff0ba9c15c9d7245dd68556e754c41f263289/src/error/GraphQLError.js#L19
+        const combinedError = new utils_1.AggregateError(errors, errors.map(error => error.message).join(', \n'));
+        const newError = (0, graphql_1.locatedError)(combinedError, undefined, path);
+        return { data: newError, unpathedErrors: [] };
+    }
+    if (!errors.length) {
+        return { data, unpathedErrors: [] };
+    }
+    const unpathedErrors = [];
+    const errorMap = new Map();
+    for (const error of errors) {
+        const pathSegment = (_a = error.path) === null || _a === void 0 ? void 0 : _a[index];
+        if (pathSegment != null) {
+            let pathSegmentErrors = errorMap.get(pathSegment);
+            if (pathSegmentErrors === undefined) {
+                pathSegmentErrors = [error];
+                errorMap.set(pathSegment, pathSegmentErrors);
+            }
+            else {
+                pathSegmentErrors.push(error);
+            }
+        }
+        else {
+            unpathedErrors.push(error);
+        }
+    }
+    for (const [pathSegment, pathSegmentErrors] of errorMap) {
+        if (data[pathSegment] !== undefined) {
+            const { data: newData, unpathedErrors: newErrors } = mergeDataAndErrors(data[pathSegment], pathSegmentErrors, path, onLocatedError, index + 1);
+            data[pathSegment] = newData;
+            unpathedErrors.push(...newErrors);
+        }
+        else {
+            unpathedErrors.push(...pathSegmentErrors);
+        }
+    }
+    return { data, unpathedErrors };
+}
+exports.mergeDataAndErrors = mergeDataAndErrors;
+function getResponseKey(info) {
+    if (info == null) {
+        throw new Error(`Data cannot be extracted from result without an explicit key or source schema.`);
+    }
+    return (0, utils_1.getResponseKeyFromInfo)(info);
+}
+function getReturnType(info) {
+    if (info == null) {
+        throw new Error(`Return type cannot be inferred without a source schema.`);
+    }
+    return info.returnType;
+}

package/cjs/createRequest.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRequest = exports.getDelegatingOperation = void 0;
+const graphql_1 = require("graphql");
+const utils_1 = require("@graphql-tools/utils");
+function getDelegatingOperation(parentType, schema) {
+    if (parentType === schema.getMutationType()) {
+        return 'mutation';
+    }
+    else if (parentType === schema.getSubscriptionType()) {
+        return 'subscription';
+    }
+    return 'query';
+}
+exports.getDelegatingOperation = getDelegatingOperation;
+function createRequest({ sourceSchema, sourceParentType, sourceFieldName, fragments, variableDefinitions, variableValues, targetRootValue, targetOperationName, targetOperation, targetFieldName, selectionSet, fieldNodes, context, info, }) {
+    var _a, _b;
+    let newSelectionSet;
+    const argumentNodeMap = Object.create(null);
+    if (selectionSet != null) {
+        newSelectionSet = selectionSet;
+    }
+    else {
+        const selections = [];
+        for (const fieldNode of fieldNodes || []) {
+            if (fieldNode.selectionSet) {
+                for (const selection of fieldNode.selectionSet.selections) {
+                    selections.push(selection);
+                }
+            }
+        }
+        newSelectionSet = selections.length
+            ? {
+                kind: graphql_1.Kind.SELECTION_SET,
+                selections,
+            }
+            : undefined;
+        const args = (_a = fieldNodes === null || fieldNodes === void 0 ? void 0 : fieldNodes[0]) === null || _a === void 0 ? void 0 : _a.arguments;
+        if (args) {
+            for (const argNode of args) {
+                argumentNodeMap[argNode.name.value] = argNode;
+            }
+        }
+    }
+    const newVariables = Object.create(null);
+    const variableDefinitionMap = Object.create(null);
+    if (sourceSchema != null && variableDefinitions != null) {
+        for (const def of variableDefinitions) {
+            const varName = def.variable.name.value;
+            variableDefinitionMap[varName] = def;
+            const varType = (0, graphql_1.typeFromAST)(sourceSchema, def.type);
+            const serializedValue = (0, utils_1.serializeInputValue)(varType, variableValues === null || variableValues === void 0 ? void 0 : variableValues[varName]);
+            if (serializedValue !== undefined) {
+                newVariables[varName] = serializedValue;
+            }
+        }
+    }
+    if (sourceParentType != null && sourceFieldName != null) {
+        updateArgumentsWithDefaults(sourceParentType, sourceFieldName, argumentNodeMap, variableDefinitionMap, newVariables);
+    }
+    const rootFieldName = targetFieldName !== null && targetFieldName !== void 0 ? targetFieldName : (_b = fieldNodes === null || fieldNodes === void 0 ? void 0 : fieldNodes[0]) === null || _b === void 0 ? void 0 : _b.name.value;
+    if (rootFieldName === undefined) {
+        throw new Error(`Either "targetFieldName" or a non empty "fieldNodes" array must be provided.`);
+    }
+    const rootfieldNode = {
+        kind: graphql_1.Kind.FIELD,
+        arguments: Object.values(argumentNodeMap),
+        name: {
+            kind: graphql_1.Kind.NAME,
+            value: rootFieldName,
+        },
+        selectionSet: newSelectionSet,
+    };
+    const operationName = targetOperationName
+        ? {
+            kind: graphql_1.Kind.NAME,
+            value: targetOperationName,
+        }
+        : undefined;
+    const operationDefinition = {
+        kind: graphql_1.Kind.OPERATION_DEFINITION,
+        name: operationName,
+        operation: targetOperation,
+        variableDefinitions: Object.values(variableDefinitionMap),
+        selectionSet: {
+            kind: graphql_1.Kind.SELECTION_SET,
+            selections: [rootfieldNode],
+        },
+    };
+    const definitions = [operationDefinition];
+    if (fragments != null) {
+        for (const fragmentName in fragments) {
+            const fragment = fragments[fragmentName];
+            definitions.push(fragment);
+        }
+    }
+    const document = {
+        kind: graphql_1.Kind.DOCUMENT,
+        definitions,
+    };
+    return {
+        document,
+        variables: newVariables,
+        rootValue: targetRootValue,
+        operationName: targetOperationName,
+        context,
+        info,
+        operationType: targetOperation,
+    };
+}
+exports.createRequest = createRequest;
+function updateArgumentsWithDefaults(sourceParentType, sourceFieldName, argumentNodeMap, variableDefinitionMap, variableValues) {
+    const generateVariableName = (0, utils_1.createVariableNameGenerator)(variableDefinitionMap);
+    const sourceField = sourceParentType.getFields()[sourceFieldName];
+    for (const argument of sourceField.args) {
+        const argName = argument.name;
+        const sourceArgType = argument.type;
+        if (argumentNodeMap[argName] === undefined) {
+            const defaultValue = argument.defaultValue;
+            if (defaultValue !== undefined) {
+                (0, utils_1.updateArgument)(argumentNodeMap, variableDefinitionMap, variableValues, argName, generateVariableName(argName), sourceArgType, (0, utils_1.serializeInputValue)(sourceArgType, defaultValue));
+            }
+        }
+    }
+}

package/cjs/defaultMergedResolver.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultMergedResolver = void 0;
+const graphql_1 = require("graphql");
+const utils_1 = require("@graphql-tools/utils");
+const resolveExternalValue_js_1 = require("./resolveExternalValue.js");
+const mergeFields_js_1 = require("./mergeFields.js");
+/**
+ * Resolver that knows how to:
+ * a) handle aliases for proxied schemas
+ * b) handle errors from proxied schemas
+ * c) handle external to internal enum conversion
+ */
+function defaultMergedResolver(parent, args, context, info) {
+    if (!parent) {
+        return null;
+    }
+    const responseKey = (0, utils_1.getResponseKeyFromInfo)(info);
+    // check to see if parent is not a proxied result, i.e. if parent resolver was manually overwritten
+    // See https://github.com/ardatan/graphql-tools/issues/967
+    if (!(0, mergeFields_js_1.isExternalObject)(parent)) {
+        return (0, graphql_1.defaultFieldResolver)(parent, args, context, info);
+    }
+    const data = parent[responseKey];
+    const unpathedErrors = (0, mergeFields_js_1.getUnpathedErrors)(parent);
+    const subschema = (0, mergeFields_js_1.getSubschema)(parent, responseKey);
+    return (0, resolveExternalValue_js_1.resolveExternalValue)(data, unpathedErrors, subschema, context, info);
+}
+exports.defaultMergedResolver = defaultMergedResolver;

package/cjs/delegateToSchema.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDefaultExecutor = exports.delegateRequest = exports.delegateToSchema = void 0;
+const graphql_1 = require("graphql");
+const value_or_promise_1 = require("value-or-promise");
+const batch_execute_1 = require("@graphql-tools/batch-execute");
+const utils_1 = require("@graphql-tools/utils");
+const subschemaConfig_js_1 = require("./subschemaConfig.js");
+const Subschema_js_1 = require("./Subschema.js");
+const createRequest_js_1 = require("./createRequest.js");
+const Transformer_js_1 = require("./Transformer.js");
+const applySchemaTransforms_js_1 = require("./applySchemaTransforms.js");
+function delegateToSchema(options) {
+    var _a, _b;
+    const { info, schema, rootValue = (_a = schema.rootValue) !== null && _a !== void 0 ? _a : info.rootValue, operationName = (_b = info.operation.name) === null || _b === void 0 ? void 0 : _b.value, operation = (0, createRequest_js_1.getDelegatingOperation)(info.parentType, info.schema), fieldName = info.fieldName, selectionSet, fieldNodes = info.fieldNodes, context, } = options;
+    const request = (0, createRequest_js_1.createRequest)({
+        sourceSchema: info.schema,
+        sourceParentType: info.parentType,
+        sourceFieldName: info.fieldName,
+        fragments: info.fragments,
+        variableDefinitions: info.operation.variableDefinitions,
+        variableValues: info.variableValues,
+        targetRootValue: rootValue,
+        targetOperationName: operationName,
+        targetOperation: operation,
+        targetFieldName: fieldName,
+        selectionSet,
+        fieldNodes,
+        context,
+        info,
+    });
+    return delegateRequest({
+        ...options,
+        request,
+    });
+}
+exports.delegateToSchema = delegateToSchema;
+function getDelegationReturnType(targetSchema, operation, fieldName) {
+    const rootType = (0, utils_1.getDefinedRootType)(targetSchema, operation);
+    return rootType.getFields()[fieldName].type;
+}
+function delegateRequest(options) {
+    const delegationContext = getDelegationContext(options);
+    const transformer = new Transformer_js_1.Transformer(delegationContext);
+    const processedRequest = transformer.transformRequest(options.request);
+    if (options.validateRequest) {
+        validateRequest(delegationContext, processedRequest.document);
+    }
+    const executor = getExecutor(delegationContext);
+    return new value_or_promise_1.ValueOrPromise(() => executor(processedRequest))
+        .then(originalResult => {
+        if ((0, utils_1.isAsyncIterable)(originalResult)) {
+            const iterator = originalResult[Symbol.asyncIterator]();
+            // "subscribe" to the subscription result and map the result through the transforms
+            return (0, utils_1.mapAsyncIterator)(iterator, result => transformer.transformResult(result));
+        }
+        return transformer.transformResult(originalResult);
+    })
+        .resolve();
+}
+exports.delegateRequest = delegateRequest;
+function getDelegationContext({ request, schema, fieldName, returnType, args, info, transforms = [], transformedSchema, skipTypeMerging = false, }) {
+    var _a, _b, _c, _d;
+    const operationDefinition = (0, utils_1.getOperationASTFromRequest)(request);
+    let targetFieldName;
+    if (fieldName == null) {
+        targetFieldName = operationDefinition.selectionSet.selections[0].name.value;
+    }
+    else {
+        targetFieldName = fieldName;
+    }
+    const stitchingInfo = (_a = info === null || info === void 0 ? void 0 : info.schema.extensions) === null || _a === void 0 ? void 0 : _a['stitchingInfo'];
+    const subschemaOrSubschemaConfig = (_b = stitchingInfo === null || stitchingInfo === void 0 ? void 0 : stitchingInfo.subschemaMap.get(schema)) !== null && _b !== void 0 ? _b : schema;
+    const operation = operationDefinition.operation;
+    if ((0, subschemaConfig_js_1.isSubschemaConfig)(subschemaOrSubschemaConfig)) {
+        const targetSchema = subschemaOrSubschemaConfig.schema;
+        return {
+            subschema: schema,
+            subschemaConfig: subschemaOrSubschemaConfig,
+            targetSchema,
+            operation,
+            fieldName: targetFieldName,
+            args,
+            context: request.context,
+            info,
+            returnType: (_c = returnType !== null && returnType !== void 0 ? returnType : info === null || info === void 0 ? void 0 : info.returnType) !== null && _c !== void 0 ? _c : getDelegationReturnType(targetSchema, operation, targetFieldName),
+            transforms: subschemaOrSubschemaConfig.transforms != null
+                ? subschemaOrSubschemaConfig.transforms.concat(transforms)
+                : transforms,
+            transformedSchema: transformedSchema !== null && transformedSchema !== void 0 ? transformedSchema : (subschemaOrSubschemaConfig instanceof Subschema_js_1.Subschema
+                ? subschemaOrSubschemaConfig.transformedSchema
+                : (0, applySchemaTransforms_js_1.applySchemaTransforms)(targetSchema, subschemaOrSubschemaConfig)),
+            skipTypeMerging,
+        };
+    }
+    return {
+        subschema: schema,
+        subschemaConfig: undefined,
+        targetSchema: subschemaOrSubschemaConfig,
+        operation,
+        fieldName: targetFieldName,
+        args,
+        context: request.context,
+        info,
+        returnType: (_d = returnType !== null && returnType !== void 0 ? returnType : info === null || info === void 0 ? void 0 : info.returnType) !== null && _d !== void 0 ? _d : getDelegationReturnType(subschemaOrSubschemaConfig, operation, targetFieldName),
+        transforms,
+        transformedSchema: transformedSchema !== null && transformedSchema !== void 0 ? transformedSchema : subschemaOrSubschemaConfig,
+        skipTypeMerging,
+    };
+}
+function validateRequest(delegationContext, document) {
+    const errors = (0, graphql_1.validate)(delegationContext.targetSchema, document);
+    if (errors.length > 0) {
+        if (errors.length > 1) {
+            const combinedError = new utils_1.AggregateError(errors, errors.map(error => error.message).join(', \n'));
+            throw combinedError;
+        }
+        const error = errors[0];
+        throw error.originalError || error;
+    }
+}
+const GLOBAL_CONTEXT = {};
+function getExecutor(delegationContext) {
+    const { subschemaConfig, targetSchema, context } = delegationContext;
+    let executor = (subschemaConfig === null || subschemaConfig === void 0 ? void 0 : subschemaConfig.executor) || (0, exports.createDefaultExecutor)(targetSchema);
+    if (subschemaConfig === null || subschemaConfig === void 0 ? void 0 : subschemaConfig.batch) {
+        const batchingOptions = subschemaConfig === null || subschemaConfig === void 0 ? void 0 : subschemaConfig.batchingOptions;
+        executor = (0, batch_execute_1.getBatchingExecutor)(context !== null && context !== void 0 ? context : GLOBAL_CONTEXT, executor, batchingOptions === null || batchingOptions === void 0 ? void 0 : batchingOptions.dataLoaderOptions, batchingOptions === null || batchingOptions === void 0 ? void 0 : batchingOptions.extensionsReducer);
+    }
+    return executor;
+}
+exports.createDefaultExecutor = (0, utils_1.memoize1)(function createDefaultExecutor(schema) {
+    return function defaultExecutor(request) {
+        const executionArgs = {
+            schema,
+            document: request.document,
+            rootValue: request.rootValue,
+            contextValue: request.context,
+            variableValues: request.variables,
+            operationName: request.operationName,
+        };
+        const operationType = request.operationType || (0, utils_1.getOperationASTFromRequest)(request).operation;
+        if (operationType === 'subscription') {
+            return (0, graphql_1.subscribe)(executionArgs);
+        }
+        return (0, graphql_1.execute)(executionArgs);
+    };
+});