@graphql-tools/delegate 8.2.2-alpha-5d885fa3.0 → 9.0.0-alpha-881b29e4.0

package/index.js

@@ -2,8 +2,11 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
+
 const graphql = require('graphql');
 const utils = require('@graphql-tools/utils');
+const DataLoader = _interopDefault(require('dataloader'));
 const valueOrPromise = require('value-or-promise');
 const batchExecute = require('@graphql-tools/batch-execute');
 
@@ -669,262 +672,6 @@ function union(...arrays) {
     return result;
 }
 
-const UNPATHED_ERRORS_SYMBOL = Symbol('subschemaErrors');
-const OBJECT_SUBSCHEMA_SYMBOL = Symbol('initialSubschema');
-const FIELD_SUBSCHEMA_MAP_SYMBOL = Symbol('subschemaMap');
-
-function isExternalObject(data) {
-    return data[UNPATHED_ERRORS_SYMBOL] !== undefined;
-}
-function annotateExternalObject(object, errors, subschema, subschemaMap) {
-    Object.defineProperties(object, {
-        [OBJECT_SUBSCHEMA_SYMBOL]: { value: subschema },
-        [FIELD_SUBSCHEMA_MAP_SYMBOL]: { value: subschemaMap },
-        [UNPATHED_ERRORS_SYMBOL]: { value: errors },
-    });
-    return object;
-}
-function getSubschema(object, responseKey) {
-    var _a;
-    return (_a = object[FIELD_SUBSCHEMA_MAP_SYMBOL][responseKey]) !== null && _a !== void 0 ? _a : object[OBJECT_SUBSCHEMA_SYMBOL];
-}
-function getUnpathedErrors(object) {
-    return object[UNPATHED_ERRORS_SYMBOL];
-}
-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;
-}
-async function executeDelegationStage(mergedTypeInfo, delegationMap, object, context, info) {
-    const combinedErrors = object[UNPATHED_ERRORS_SYMBOL];
-    const path = graphql.responsePathAsArray(info.path);
-    const combinedFieldSubschemaMap = object[FIELD_SUBSCHEMA_MAP_SYMBOL];
-    const type = info.schema.getType(object.__typename);
-    await Promise.all([...delegationMap.entries()].map(async ([s, selectionSet]) => {
-        var _a;
-        const resolver = mergedTypeInfo.resolvers.get(s);
-        if (resolver) {
-            let source;
-            try {
-                source = await resolver(object, context, info, s, selectionSet);
-            }
-            catch (error) {
-                source = error;
-            }
-            if (source instanceof Error || source == null) {
-                const fieldNodeResponseKeyMap = utils.collectFields(info.schema, {}, {}, type, selectionSet, new Map(), new Set());
-                const nullResult = {};
-                for (const [responseKey, fieldNodes] of fieldNodeResponseKeyMap) {
-                    const combinedPath = [...path, responseKey];
-                    if (source instanceof graphql.GraphQLError) {
-                        nullResult[responseKey] = utils.relocatedError(source, combinedPath);
-                    }
-                    else if (source instanceof Error) {
-                        nullResult[responseKey] = graphql.locatedError(source, fieldNodes, combinedPath);
-                    }
-                    else {
-                        nullResult[responseKey] = null;
-                    }
-                }
-                source = nullResult;
-            }
-            else {
-                if (source[UNPATHED_ERRORS_SYMBOL]) {
-                    combinedErrors.push(...source[UNPATHED_ERRORS_SYMBOL]);
-                }
-            }
-            const objectSubschema = source[OBJECT_SUBSCHEMA_SYMBOL];
-            const fieldSubschemaMap = source[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;
-            }
-        }
-    }));
-}
-
-function resolveExternalValue(result, unpathedErrors, subschema, context, info, returnType = getReturnType(info), skipTypeMerging) {
-    const type = graphql.getNullableType(returnType);
-    if (result instanceof Error) {
-        return result;
-    }
-    if (result == null) {
-        return reportUnpathedErrorsViaNull(unpathedErrors);
-    }
-    if ('parseValue' in type) {
-        return type.parseValue(result);
-    }
-    else if (graphql.isCompositeType(type)) {
-        return resolveExternalObject(type, result, unpathedErrors, subschema, context, info, skipTypeMerging);
-    }
-    else if (graphql.isListType(type)) {
-        return resolveExternalList(type, result, unpathedErrors, subschema, context, info, skipTypeMerging);
-    }
-}
-function resolveExternalObject(type, object, unpathedErrors, subschema, context, info, skipTypeMerging) {
-    var _a;
-    // if we have already resolved this object, for example, when the identical object appears twice
-    // in a list, see https://github.com/ardatan/graphql-tools/issues/2304
-    if (!isExternalObject(object)) {
-        annotateExternalObject(object, unpathedErrors, subschema, Object.create(null));
-    }
-    if (skipTypeMerging || info == null) {
-        return object;
-    }
-    const stitchingInfo = (_a = info.schema.extensions) === null || _a === void 0 ? void 0 : _a['stitchingInfo'];
-    if (stitchingInfo == null) {
-        return object;
-    }
-    let typeName;
-    if (graphql.isAbstractType(type)) {
-        const resolvedType = info.schema.getType(object.__typename);
-        if (resolvedType == null) {
-            throw new Error(`Unable to resolve type '${object.__typename}'. Did you forget to include a transform that renames types? Did you delegate to the original subschema rather that the subschema config object containing the transform?`);
-        }
-        typeName = resolvedType.name;
-    }
-    else {
-        typeName = type.name;
-    }
-    const mergedTypeInfo = stitchingInfo.mergedTypes[typeName];
-    let targetSubschemas;
-    // Within the stitching context, delegation to a stitched GraphQLSchema or SubschemaConfig
-    // will be redirected to the appropriate Subschema object, from which merge targets can be queried.
-    if (mergedTypeInfo != null) {
-        targetSubschemas = mergedTypeInfo.targetSubschemas.get(subschema);
-    }
-    // If there are no merge targets from the subschema, return.
-    if (!targetSubschemas || !targetSubschemas.length) {
-        return object;
-    }
-    return mergeFields(mergedTypeInfo, object, subschema, context, info);
-}
-function resolveExternalList(type, list, unpathedErrors, subschema, context, info, skipTypeMerging) {
-    return list.map(listMember => resolveExternalListMember(graphql.getNullableType(type.ofType), listMember, unpathedErrors, subschema, context, info, skipTypeMerging));
-}
-function resolveExternalListMember(type, listMember, unpathedErrors, subschema, context, info, skipTypeMerging) {
-    if (listMember instanceof Error) {
-        return listMember;
-    }
-    if (listMember == null) {
-        return reportUnpathedErrorsViaNull(unpathedErrors);
-    }
-    if ('parseValue' in type) {
-        return type.parseValue(listMember);
-    }
-    else if (graphql.isCompositeType(type)) {
-        return resolveExternalObject(type, listMember, unpathedErrors, subschema, context, info, skipTypeMerging);
-    }
-    else if (graphql.isListType(type)) {
-        return resolveExternalList(type, listMember, unpathedErrors, subschema, context, info, skipTypeMerging);
-    }
-}
-const reportedErrors = new WeakMap();
-function reportUnpathedErrorsViaNull(unpathedErrors) {
-    if (unpathedErrors.length) {
-        const unreportedErrors = [];
-        for (const error of unpathedErrors) {
-            if (!reportedErrors.has(error)) {
-                unreportedErrors.push(error);
-                reportedErrors.set(error, true);
-            }
-        }
-        if (unreportedErrors.length) {
-            if (unreportedErrors.length === 1) {
-                return unreportedErrors[0];
-            }
-            const combinedError = new utils.AggregateError(unreportedErrors);
-            // 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
-            return graphql.locatedError(combinedError, undefined, unreportedErrors[0].path);
-        }
-    }
-    return null;
-}
-function getReturnType(info) {
-    if (info == null) {
-        throw new Error(`Return type cannot be inferred without a source schema.`);
-    }
-    return info.returnType;
-}
-
-function checkResultAndHandleErrors(result, delegationContext) {
-    const { context, info, fieldName: responseKey = getResponseKey(info), subschema, returnType = getReturnType$1(info), skipTypeMerging, onLocatedError, } = delegationContext;
-    const { data, unpathedErrors } = mergeDataAndErrors(result.data == null ? undefined : result.data[responseKey], result.errors == null ? [] : result.errors, info != null && info.path ? graphql.responsePathAsArray(info.path) : undefined, onLocatedError);
-    return resolveExternalValue(data, unpathedErrors, subschema, context, info, returnType, skipTypeMerging);
-}
-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 === undefined ? path : path.concat(error.path.slice(1));
-            return { data: utils.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 newError = graphql.locatedError(new utils.AggregateError(errors), 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 };
-}
-function getResponseKey(info) {
-    if (info == null) {
-        throw new Error(`Data cannot be extracted from result without an explicit key or source schema.`);
-    }
-    return utils.getResponseKeyFromInfo(info);
-}
-function getReturnType$1(info) {
-    if (info == null) {
-        throw new Error(`Return type cannot be inferred without a source schema.`);
-    }
-    return info.returnType;
-}
-
 class Transformer {
     constructor(context) {
         this.transformations = [];
@@ -960,7 +707,7 @@ class Transformer {
                 result = transformation.transform.transformResult(result, this.delegationContext, transformation.context);
             }
         }
-        return checkResultAndHandleErrors(result, this.delegationContext);
+        return result;
     }
 }
 
@@ -1101,70 +848,578 @@ function updateArgumentsWithDefaults(sourceParentType, sourceFieldName, argument
     }
 }
 
-/**
- * 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 = utils.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 (!isExternalObject(parent)) {
-        return graphql.defaultFieldResolver(parent, args, context, info);
+const INITIAL_PATH_SYMBOL = Symbol('initialPath');
+const UNPATHED_ERRORS_SYMBOL = Symbol('unpathedErrors');
+const OBJECT_SUBSCHEMA_SYMBOL = Symbol('initialSubschema');
+const INITIAL_POSSIBLE_FIELDS = Symbol('initialPossibleFields');
+const INFO_SYMBOL = Symbol('info');
+const RESPONSE_KEY_SUBSCHEMA_MAP_SYMBOL = Symbol('subschemaMap');
+
+function isExternalObject(data) {
+    return (data === null || data === void 0 ? void 0 : data[UNPATHED_ERRORS_SYMBOL]) !== undefined;
+}
+function annotateExternalObject(object, errors, initialPath, subschema, info) {
+    var _a, _b, _c;
+    if (isExternalObject(object)) {
+        return object;
     }
-    const data = parent[responseKey];
-    const unpathedErrors = getUnpathedErrors(parent);
-    const subschema = getSubschema(parent, responseKey);
-    return resolveExternalValue(data, unpathedErrors, subschema, context, info);
+    const schema = subschema instanceof Subschema ? subschema.transformedSchema : (_b = (_a = subschema) === null || _a === void 0 ? void 0 : _a.schema) !== null && _b !== void 0 ? _b : subschema;
+    const initialPossibleFields = (_c = schema.getType(object.__typename)) === null || _c === void 0 ? void 0 : _c.getFields();
+    Object.defineProperties(object, {
+        [INITIAL_PATH_SYMBOL]: { value: initialPath },
+        [OBJECT_SUBSCHEMA_SYMBOL]: { value: subschema },
+        [INITIAL_POSSIBLE_FIELDS]: { value: initialPossibleFields },
+        [INFO_SYMBOL]: { value: info },
+        [RESPONSE_KEY_SUBSCHEMA_MAP_SYMBOL]: { value: Object.create(null) },
+        [UNPATHED_ERRORS_SYMBOL]: { value: errors },
+    });
+    return object;
+}
+function getInitialPath(object) {
+    return object[INITIAL_PATH_SYMBOL];
+}
+function getInitialPossibleFields(object) {
+    return object[INITIAL_POSSIBLE_FIELDS];
+}
+function getInfo(object) {
+    return object[INFO_SYMBOL];
+}
+function getUnpathedErrors(object) {
+    return object[UNPATHED_ERRORS_SYMBOL];
+}
+function getObjectSubchema(object) {
+    return object[OBJECT_SUBSCHEMA_SYMBOL];
+}
+function getSubschemaMap(object) {
+    return object[RESPONSE_KEY_SUBSCHEMA_MAP_SYMBOL];
+}
+function getSubschema(object, responseKey) {
+    var _a;
+    return (_a = object[RESPONSE_KEY_SUBSCHEMA_MAP_SYMBOL][responseKey]) !== null && _a !== void 0 ? _a : object[OBJECT_SUBSCHEMA_SYMBOL];
 }
 
-function isSubschemaConfig(value) {
-    return Boolean(value === null || value === void 0 ? void 0 : value.schema);
+function mergeDataAndErrors(data, errors = [], onLocatedError = (originalError) => originalError, index = 1) {
+    var _a;
+    if (data == null) {
+        if (!errors.length) {
+            return { data: null, unpathedErrors: [] };
+        }
+        if (errors.length === 1) {
+            const error = onLocatedError(errors[0]);
+            const newPath = error.path === undefined ? [] : error.path.slice(1);
+            const newError = utils.relocatedError(error, newPath);
+            return { data: newError, unpathedErrors: [] };
+        }
+        const newErrors = errors.map(error => onLocatedError(error));
+        const firstError = newErrors[0];
+        const newPath = firstError.path === undefined ? [] : firstError.path.slice(1);
+        // 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 newError = graphql.locatedError(new utils.AggregateError(newErrors), undefined, newPath);
+        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, onLocatedError, index + 1);
+            data[pathSegment] = newData;
+            unpathedErrors.push(...newErrors);
+        }
+        else {
+            unpathedErrors.push(...pathSegmentErrors);
+        }
+    }
+    return { data, unpathedErrors };
 }
-function cloneSubschemaConfig(subschemaConfig) {
+
+function externalValueFromResult({ result, schema, info, context, fieldName = getFieldName(info), returnType = getReturnType(info), onLocatedError = (error) => error, }) {
     var _a, _b;
-    const newSubschemaConfig = {
-        ...subschemaConfig,
-        transforms: subschemaConfig.transforms != null ? [...subschemaConfig.transforms] : undefined,
+    const data = (_a = result.data) === null || _a === void 0 ? void 0 : _a[fieldName];
+    const errors = (_b = result.errors) !== null && _b !== void 0 ? _b : [];
+    const initialPath = info ? graphql.responsePathAsArray(info.path) : [];
+    const { data: newData, unpathedErrors } = mergeDataAndErrors(data, errors, onLocatedError);
+    return createExternalValue(newData, unpathedErrors, initialPath, schema, context, info, returnType);
+}
+function createExternalValue(data, unpathedErrors, initialPath, subschema, context, info, returnType = getReturnType(info)) {
+    const type = graphql.getNullableType(returnType);
+    if (data instanceof graphql.GraphQLError) {
+        return utils.relocatedError(data, data.path ? initialPath.concat(data.path) : initialPath);
+    }
+    if (data instanceof Error) {
+        return data;
+    }
+    if (data == null) {
+        return reportUnpathedErrorsViaNull(unpathedErrors);
+    }
+    if ('parseValue' in type) {
+        return type.parseValue(data);
+    }
+    else if (graphql.isCompositeType(type)) {
+        return annotateExternalObject(data, unpathedErrors, initialPath, subschema, info);
+    }
+    else if (graphql.isListType(type)) {
+        return createExternalList(type, data, unpathedErrors, initialPath, subschema, context, info);
+    }
+}
+function createExternalList(type, list, unpathedErrors, initialPath, subschema, context, info) {
+    return list.map(listMember => createExternalListMember(graphql.getNullableType(type.ofType), listMember, unpathedErrors, initialPath, subschema, context, info));
+}
+function createExternalListMember(type, listMember, unpathedErrors, initialPath, subschema, context, info) {
+    if (listMember instanceof graphql.GraphQLError) {
+        return utils.relocatedError(listMember, listMember.path ? initialPath.concat(listMember.path) : initialPath);
+    }
+    if (listMember instanceof Error) {
+        return listMember;
+    }
+    if (listMember == null) {
+        return reportUnpathedErrorsViaNull(unpathedErrors);
+    }
+    if ('parseValue' in type) {
+        return type.parseValue(listMember);
+    }
+    else if (graphql.isCompositeType(type)) {
+        return annotateExternalObject(listMember, unpathedErrors, initialPath, subschema, info);
+    }
+    else if (graphql.isListType(type)) {
+        return createExternalList(type, listMember, unpathedErrors, initialPath, subschema, context, info);
+    }
+}
+const reportedErrors = new WeakMap();
+function reportUnpathedErrorsViaNull(unpathedErrors) {
+    if (unpathedErrors.length) {
+        const unreportedErrors = [];
+        for (const error of unpathedErrors) {
+            if (!reportedErrors.has(error)) {
+                unreportedErrors.push(error);
+                reportedErrors.set(error, true);
+            }
+        }
+        if (unreportedErrors.length) {
+            if (unreportedErrors.length === 1) {
+                return unreportedErrors[0];
+            }
+            const combinedError = new utils.AggregateError(unreportedErrors);
+            // 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
+            return graphql.locatedError(combinedError, undefined, unreportedErrors[0].path);
+        }
+    }
+    return null;
+}
+function getFieldName(info) {
+    if (info == null) {
+        throw new Error(`Data cannot be extracted from result without an explicit key or source schema.`);
+    }
+    return info.fieldName;
+}
+function getReturnType(info) {
+    if (info == null) {
+        throw new Error(`Return type cannot be inferred without a source schema.`);
+    }
+    return info.returnType;
+}
+
+const getMergedTypeInfo = utils.memoize1(function getMergedTypeInfo(info) {
+    var _a;
+    const schema = info.schema;
+    const stitchingInfo = (_a = schema.extensions) === null || _a === void 0 ? void 0 : _a['stitchingInfo'];
+    if (stitchingInfo == null) {
+        return;
+    }
+    const parentTypeName = info.parentType.name;
+    const mergedTypeInfo = stitchingInfo.mergedTypes[parentTypeName];
+    if (mergedTypeInfo === undefined) {
+        return;
+    }
+    return mergedTypeInfo;
+});
+const loaders = new WeakMap();
+async function getMergedParent(parent, context, info) {
+    const mergedTypeInfo = getMergedTypeInfo(info);
+    if (!mergedTypeInfo) {
+        return parent;
+    }
+    // In the stitching context, all subschemas are compiled Subschema objects rather than SubschemaConfig objects
+    const sourceSubschema = getObjectSubchema(parent);
+    let loader = loaders.get(parent);
+    if (loader === undefined) {
+        loader = new DataLoader(fieldNodeArrays => getMergedParentsFromFieldNodes(parent, context, info.schema, fieldNodeArrays, mergedTypeInfo, sourceSubschema));
+        loaders.set(parent, loader);
+    }
+    return loader.load(info.fieldNodes);
+}
+async function getMergedParentsFromFieldNodes(parent, context, gatewaySchema, fieldNodeArrays, mergedTypeInfo, sourceSubschema) {
+    const { requiredKeys, delegationMaps, stageMap } = buildDelegationPlan(mergedTypeInfo, gatewaySchema, sourceSubschema, ...fieldNodeArrays);
+    if (!delegationMaps.length) {
+        return Array(fieldNodeArrays.length).fill(parent);
+    }
+    const promises = [];
+    const parentInfo = getInfo(parent);
+    const schema = parentInfo.schema;
+    const type = schema.getType(parent.__typename);
+    const parentPath = graphql.responsePathAsArray(parentInfo.path);
+    let promise = executeDelegationStage(delegationMaps[0], schema, type, mergedTypeInfo, context, parent, parentInfo, parentPath);
+    promises.push(promise);
+    for (let i = 1, delegationStage = delegationMaps[i]; i < delegationMaps.length; i++) {
+        promise = promise.then(parent => executeDelegationStage(delegationStage, schema, type, mergedTypeInfo, context, parent, parentInfo, parentPath));
+        promises.push(promise);
+    }
+    return fieldNodeArrays.map(fieldNodeArray => {
+        const fieldName = fieldNodeArray[0].name.value;
+        const keys = requiredKeys[fieldName];
+        if (keys === undefined) {
+            const delegationStage = stageMap[fieldName];
+            if (delegationStage !== undefined) {
+                return promises[delegationStage];
+            }
+            return Promise.resolve(parent);
+        }
+        return Promise.all(Array.from(keys.values()).map(fieldName => {
+            const delegationStage = stageMap[fieldName];
+            if (delegationStage !== undefined) {
+                return promises[delegationStage];
+            }
+            return Promise.resolve(parent);
+        })).then(() => parent);
+    });
+}
+function sortSubschemasByProxiability(mergedTypeInfo, sourceSubschemas, targetSubschemas, fieldNodes) {
+    // 1.  calculate if possible to delegate to given subschema
+    const proxiableSubschemas = [];
+    const nonProxiableSubschemas = [];
+    for (const t of targetSubschemas) {
+        const selectionSet = mergedTypeInfo.selectionSets.get(t);
+        const fieldSelectionSets = mergedTypeInfo.fieldSelectionSets.get(t);
+        if (selectionSet != null && !subschemaTypesContainSelectionSet(mergedTypeInfo, sourceSubschemas, selectionSet)) {
+            nonProxiableSubschemas.push(t);
+        }
+        else {
+            if (fieldSelectionSets == null ||
+                fieldNodes.every(fieldNode => {
+                    const fieldName = fieldNode.name.value;
+                    const fieldSelectionSet = fieldSelectionSets[fieldName];
+                    return (fieldSelectionSet == null ||
+                        subschemaTypesContainSelectionSet(mergedTypeInfo, sourceSubschemas, fieldSelectionSet));
+                })) {
+                proxiableSubschemas.push(t);
+            }
+            else {
+                nonProxiableSubschemas.push(t);
+            }
+        }
+    }
+    return {
+        proxiableSubschemas,
+        nonProxiableSubschemas,
     };
-    if (newSubschemaConfig.merge != null) {
-        newSubschemaConfig.merge = { ...subschemaConfig.merge };
-        for (const typeName in newSubschemaConfig.merge) {
-            const mergedTypeConfig = (newSubschemaConfig.merge[typeName] = { ...((_b = (_a = subschemaConfig.merge) === null || _a === void 0 ? void 0 : _a[typeName]) !== null && _b !== void 0 ? _b : {}) });
-            if (mergedTypeConfig.entryPoints != null) {
-                mergedTypeConfig.entryPoints = mergedTypeConfig.entryPoints.map(entryPoint => ({ ...entryPoint }));
+}
+function calculateDelegationStage(mergedTypeInfo, sourceSubschemas, targetSubschemas, fieldNodes) {
+    const { proxiableSubschemas, nonProxiableSubschemas } = sortSubschemasByProxiability(mergedTypeInfo, sourceSubschemas, targetSubschemas, fieldNodes);
+    const { delegationMap, proxiableFieldNodes, unproxiableFieldNodes } = buildDelegationStage(mergedTypeInfo, fieldNodes, proxiableSubschemas);
+    return {
+        proxiableSubschemas,
+        nonProxiableSubschemas,
+        delegationMap,
+        proxiableFieldNodes,
+        unproxiableFieldNodes,
+    };
+}
+const buildDelegationPlan = utils.memoize4ofMany(function buildDelegationPlan(mergedTypeInfo, gatewaySchema, sourceSubschema, ...fieldNodeArrays) {
+    var _a, _b, _c;
+    const requiredKeys = Object.create(null);
+    const delegationMaps = [];
+    const stageMap = Object.create(null);
+    const stitchingInfo = (_a = gatewaySchema.extensions) === null || _a === void 0 ? void 0 : _a['stitchingInfo'];
+    if (stitchingInfo == null) {
+        return { requiredKeys, delegationMaps, stageMap };
+    }
+    const targetSubschemas = mergedTypeInfo.targetSubschemas.get(sourceSubschema);
+    if (targetSubschemas === undefined || targetSubschemas.length === 0) {
+        return { requiredKeys, delegationMaps, stageMap };
+    }
+    const parentTypeName = mergedTypeInfo.typeName;
+    const sourceSubschemaParentType = sourceSubschema.transformedSchema.getType(parentTypeName);
+    const sourceSubschemaFields = sourceSubschemaParentType.getFields();
+    const subschemaFields = mergedTypeInfo.subschemaFields;
+    const typeFieldNodes = (_b = stitchingInfo.fieldNodesByField) === null || _b === void 0 ? void 0 : _b[parentTypeName];
+    const fieldNodeSet = new Set();
+    const fieldNodesByType = (_c = stitchingInfo.fieldNodesByType) === null || _c === void 0 ? void 0 : _c[parentTypeName];
+    if (fieldNodesByType !== undefined) {
+        for (const fieldNode of fieldNodesByType) {
+            const fieldName = fieldNode.name.value;
+            if (!sourceSubschemaFields[fieldName]) {
+                const fieldName = fieldNode.name.value;
+                if (!sourceSubschemaFields[fieldName]) {
+                    fieldNodeSet.add(fieldNode);
+                }
             }
-            if (mergedTypeConfig.fields != null) {
-                const fields = (mergedTypeConfig.fields = { ...mergedTypeConfig.fields });
-                for (const fieldName in fields) {
-                    fields[fieldName] = { ...fields[fieldName] };
+        }
+    }
+    for (const fieldNodeArray of fieldNodeArrays) {
+        const fieldName = fieldNodeArray[0].name.value;
+        if (subschemaFields[fieldName] !== undefined) {
+            // merged subschema field
+            for (const fieldNode of fieldNodeArray) {
+                const fieldName = fieldNode.name.value;
+                if (!sourceSubschemaFields[fieldName]) {
+                    fieldNodeSet.add(fieldNode);
                 }
             }
         }
+        else {
+            // gateway field
+            if (requiredKeys[fieldName] === undefined) {
+                requiredKeys[fieldName] = new Set();
+            }
+        }
+        const keyFieldNodes = new Set();
+        const fieldNodesByField = typeFieldNodes === null || typeFieldNodes === void 0 ? void 0 : typeFieldNodes[fieldName];
+        if (fieldNodesByField !== undefined) {
+            for (const fieldNode of fieldNodesByField) {
+                keyFieldNodes.add(fieldNode);
+            }
+        }
+        if (requiredKeys[fieldName] !== undefined) {
+            for (const fieldNode of keyFieldNodes.values()) {
+                requiredKeys[fieldName].add(fieldNode.name.value);
+            }
+        }
+        for (const fieldNode of keyFieldNodes) {
+            fieldNodeSet.add(fieldNode);
+        }
     }
-    return newSubschemaConfig;
+    const fieldNodes = Array.from(fieldNodeSet);
+    let sourceSubschemas = [sourceSubschema];
+    let delegationStage = calculateDelegationStage(mergedTypeInfo, sourceSubschemas, targetSubschemas, fieldNodes);
+    let stageIndex = 0;
+    let delegationMap = delegationStage.delegationMap;
+    while (delegationMap.size) {
+        delegationMaps.push(delegationMap);
+        const { proxiableSubschemas, nonProxiableSubschemas, proxiableFieldNodes, unproxiableFieldNodes } = delegationStage;
+        sourceSubschemas = sourceSubschemas.concat(proxiableSubschemas);
+        for (const fieldNode of proxiableFieldNodes) {
+            stageMap[fieldNode.name.value] = stageIndex;
+        }
+        stageIndex++;
+        delegationStage = calculateDelegationStage(mergedTypeInfo, sourceSubschemas, nonProxiableSubschemas, unproxiableFieldNodes);
+        delegationMap = delegationStage.delegationMap;
+    }
+    return {
+        requiredKeys,
+        delegationMaps,
+        stageMap,
+    };
+});
+function buildDelegationStage(mergedTypeInfo, fieldNodes, proxiableSubschemas) {
+    const { uniqueFields, nonUniqueFields } = mergedTypeInfo;
+    const proxiableFieldNodes = [];
+    const unproxiableFieldNodes = [];
+    // 2. for each selection:
+    const delegationMap = new Map();
+    for (const fieldNode of fieldNodes) {
+        if (fieldNode.name.value === '__typename') {
+            continue;
+        }
+        // 2a. use uniqueFields map to assign fields to subschema if one of possible subschemas
+        const uniqueSubschema = uniqueFields[fieldNode.name.value];
+        if (uniqueSubschema != null) {
+            if (!proxiableSubschemas.includes(uniqueSubschema)) {
+                unproxiableFieldNodes.push(fieldNode);
+                continue;
+            }
+            const existingSubschema = delegationMap.get(uniqueSubschema);
+            if (existingSubschema != null) {
+                existingSubschema.push(fieldNode);
+            }
+            else {
+                delegationMap.set(uniqueSubschema, [fieldNode]);
+            }
+            proxiableFieldNodes.push(fieldNode);
+            continue;
+        }
+        // 2b. use nonUniqueFields to assign to a possible subschema,
+        //     preferring one of the subschemas already targets of delegation
+        let nonUniqueSubschemas = nonUniqueFields[fieldNode.name.value];
+        if (nonUniqueSubschemas == null) {
+            unproxiableFieldNodes.push(fieldNode);
+            continue;
+        }
+        nonUniqueSubschemas = nonUniqueSubschemas.filter(s => proxiableSubschemas.includes(s));
+        if (!nonUniqueSubschemas.length) {
+            unproxiableFieldNodes.push(fieldNode);
+            continue;
+        }
+        const existingSubschema = nonUniqueSubschemas.find(s => delegationMap.has(s));
+        if (existingSubschema != null) {
+            // It is okay we previously explicitly check whether the map has the element.
+            delegationMap.get(existingSubschema).push(fieldNode);
+        }
+        else {
+            delegationMap.set(nonUniqueSubschemas[0], [fieldNode]);
+        }
+        proxiableFieldNodes.push(fieldNode);
+    }
+    return {
+        delegationMap,
+        proxiableFieldNodes,
+        unproxiableFieldNodes,
+    };
+}
+async function executeDelegationStage(delegationMap, schema, type, mergedTypeInfo, context, object, parentInfo, parentPath) {
+    const initialPath = getInitialPath(object);
+    const newSubschemaMap = getSubschemaMap(object);
+    const unpathedErrors = getUnpathedErrors(object);
+    await Promise.all([...delegationMap.entries()].map(async ([s, fieldNodes]) => {
+        var _a;
+        const resolver = mergedTypeInfo.resolvers.get(s);
+        if (resolver) {
+            const selectionSet = { kind: graphql.Kind.SELECTION_SET, selections: fieldNodes };
+            let source;
+            try {
+                source = await resolver(object, context, parentInfo, s, selectionSet);
+            }
+            catch (error) {
+                source = error;
+            }
+            if (source instanceof Error || source === null) {
+                const fieldNodes = utils.collectFields(schema, {}, {}, type, selectionSet, new Map(), new Set());
+                const nullResult = Object.create(null);
+                if (source instanceof graphql.GraphQLError && source.path) {
+                    const basePath = parentPath.slice(initialPath.length);
+                    for (const [responseKey] of fieldNodes) {
+                        const tailPath = source.path.length === parentPath.length ? [responseKey] : source.path.slice(initialPath.length);
+                        const newPath = basePath.concat(tailPath);
+                        nullResult[responseKey] = utils.relocatedError(source, newPath);
+                    }
+                }
+                else if (source instanceof Error) {
+                    const basePath = parentPath.slice(initialPath.length);
+                    for (const [responseKey] of fieldNodes) {
+                        const newPath = basePath.concat([responseKey]);
+                        nullResult[responseKey] = graphql.locatedError(source, fieldNodes[responseKey], newPath);
+                    }
+                }
+                else {
+                    for (const [responseKey] of fieldNodes) {
+                        nullResult[responseKey] = null;
+                    }
+                }
+                source = nullResult;
+            }
+            // TODO: is this check necessary or just to make TS happy?
+            if (!isExternalObject(source)) {
+                Object.assign(object, source);
+                return object;
+            }
+            const objectSubschema = getObjectSubchema(source);
+            const subschemaMap = getSubschemaMap(source);
+            for (const responseKey in source) {
+                object[responseKey] = source[responseKey];
+                newSubschemaMap[responseKey] = (_a = subschemaMap === null || subschemaMap === void 0 ? void 0 : subschemaMap[responseKey]) !== null && _a !== void 0 ? _a : objectSubschema;
+            }
+            unpathedErrors.push(...getUnpathedErrors(source));
+        }
+    }));
+    return object;
+}
+const subschemaTypesContainSelectionSet = utils.memoize3(function subschemaTypesContainSelectionSet(mergedTypeInfo, sourceSubschemas, selectionSet) {
+    return typesContainSelectionSet(sourceSubschemas.map(sourceSubschema => sourceSubschema.transformedSchema.getType(mergedTypeInfo.typeName)), selectionSet);
+});
+function typesContainSelectionSet(types, selectionSet) {
+    var _a;
+    const fieldMaps = types.map(type => type.getFields());
+    for (const selection of selectionSet.selections) {
+        if (selection.kind === graphql.Kind.FIELD) {
+            const fields = fieldMaps.map(fieldMap => fieldMap[selection.name.value]).filter(field => field != null);
+            if (!fields.length) {
+                return false;
+            }
+            if (selection.selectionSet != null) {
+                return typesContainSelectionSet(fields.map(field => graphql.getNamedType(field.type)), selection.selectionSet);
+            }
+        }
+        else if (selection.kind === graphql.Kind.INLINE_FRAGMENT && ((_a = selection.typeCondition) === null || _a === void 0 ? void 0 : _a.name.value) === types[0].name) {
+            return typesContainSelectionSet(types, selection.selectionSet);
+        }
+    }
+    return true;
+}
+
+/**
+ * Resolver that knows how to:
+ * a) handle aliases for proxied schemas
+ * b) handle errors from proxied schemas
+ * c) handle external to internal enum/scalar conversion
+ * d) handle type merging
+ * e) handle deferred values
+ */
+function defaultMergedResolver(parent, args, context, info) {
+    if (!isExternalObject(parent)) {
+        return graphql.defaultFieldResolver(parent, args, context, info);
+    }
+    const responseKey = utils.getResponseKeyFromInfo(info);
+    const initialPossibleFields = getInitialPossibleFields(parent);
+    if (initialPossibleFields === undefined) {
+        // TODO: can this be removed in the next major release?
+        // legacy use of  delegation without setting transformedSchema
+        const data = parent[responseKey];
+        if (data !== undefined) {
+            return resolveField(parent, responseKey, context, info);
+        }
+    }
+    else if (info.fieldName in initialPossibleFields) {
+        return resolveField(parent, responseKey, context, info);
+    }
+    return getMergedParent(parent, context, info).then(mergedParent => resolveField(mergedParent, responseKey, context, info));
+}
+function resolveField(parent, responseKey, context, info) {
+    const initialPath = getInitialPath(parent);
+    const subschema = getSubschema(parent, responseKey);
+    const unpathedErrors = getUnpathedErrors(parent);
+    return createExternalValue(parent[responseKey], unpathedErrors, initialPath, subschema, context, info);
 }
 
 function delegateToSchema(options) {
-    const { info, schema, rootValue, operationName, operation = getDelegatingOperation(info.parentType, info.schema), fieldName = info.fieldName, selectionSet, fieldNodes, context, } = options;
+    const { info, schema, rootValue = schema.rootValue, operationName, operation = getDelegatingOperation(info.parentType, info.schema), fieldName = info.fieldName, selectionSet, fieldNodes, context, } = options;
     const request = createRequestFromInfo({
         info,
         operation,
         fieldName,
         selectionSet,
         fieldNodes,
-        rootValue: rootValue !== null && rootValue !== void 0 ? rootValue : schema.rootValue,
+        rootValue,
         operationName,
         context,
     });
     return delegateRequest({
         ...options,
         request,
+        operation,
+        fieldName,
     });
 }
 function getDelegationReturnType(targetSchema, operation, fieldName) {
@@ -1172,10 +1427,30 @@ function getDelegationReturnType(targetSchema, operation, fieldName) {
     return rootType.getFields()[fieldName].type;
 }
 function delegateRequest(options) {
-    const delegationContext = getDelegationContext(options);
+    var _a;
+    let operationDefinition;
+    let targetFieldName;
+    const { document, operationName } = options.request;
+    if (options.fieldName == null) {
+        operationDefinition = graphql.getOperationAST(document, operationName);
+        if (operationDefinition == null) {
+            throw new Error('Cannot infer main operation from the provided document.');
+        }
+        targetFieldName = (operationDefinition === null || operationDefinition === void 0 ? void 0 : operationDefinition.selectionSet.selections[0]).name.value;
+    }
+    else {
+        targetFieldName = options.fieldName;
+    }
+    const { schema, info, operation = getDelegatingOperation(info.parentType, info.schema), returnType = (_a = info === null || info === void 0 ? void 0 : info.returnType) !== null && _a !== void 0 ? _a : getDelegationReturnType(schema instanceof graphql.GraphQLSchema ? schema : schema.schema, operation, targetFieldName), context, onLocatedError = (error) => error, validateRequest: shouldValidateRequest, } = options;
+    const delegationContext = getDelegationContext({
+        ...options,
+        operation,
+        fieldName: targetFieldName,
+        returnType,
+    });
     const transformer = new Transformer(delegationContext);
     const processedRequest = transformer.transformRequest(options.request);
-    if (options.validateRequest) {
+    if (shouldValidateRequest) {
         validateRequest(delegationContext, processedRequest.document);
     }
     const executor = getExecutor(delegationContext);
@@ -1183,13 +1458,29 @@ function delegateRequest(options) {
         .then(originalResult => {
         if (utils.isAsyncIterable(originalResult)) {
             // "subscribe" to the subscription result and map the result through the transforms
-            return utils.mapAsyncIterator(originalResult, result => transformer.transformResult(result));
+            return utils.mapAsyncIterator(originalResult, result => externalValueFromResult({
+                result: transformer.transformResult(result),
+                schema,
+                info,
+                context,
+                fieldName: targetFieldName,
+                returnType,
+                onLocatedError,
+            }));
         }
-        return transformer.transformResult(originalResult);
+        return externalValueFromResult({
+            result: transformer.transformResult(originalResult),
+            schema,
+            info,
+            context,
+            fieldName: targetFieldName,
+            returnType,
+            onLocatedError,
+        });
     })
         .resolve();
 }
-function getDelegationContext({ request, schema, fieldName, returnType, args, info, transforms = [], transformedSchema, skipTypeMerging = false, }) {
+function getDelegationContext({ request, schema, fieldName, returnType, args, info, transforms = [], transformedSchema, }) {
     var _a, _b, _c, _d;
     const { operationType: operation, context, operationName, document } = request;
     let operationDefinition;
@@ -1206,7 +1497,7 @@ function getDelegationContext({ request, schema, fieldName, returnType, args, in
     }
     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;
-    if (isSubschemaConfig(subschemaOrSubschemaConfig)) {
+    if (!graphql.isSchema(subschemaOrSubschemaConfig)) {
         const targetSchema = subschemaOrSubschemaConfig.schema;
         return {
             subschema: schema,
@@ -1222,7 +1513,6 @@ function getDelegationContext({ request, schema, fieldName, returnType, args, in
                 ? subschemaOrSubschemaConfig.transforms.concat(transforms)
                 : transforms,
             transformedSchema: transformedSchema !== null && transformedSchema !== void 0 ? transformedSchema : (subschemaOrSubschemaConfig instanceof Subschema ? subschemaOrSubschemaConfig.transformedSchema : targetSchema),
-            skipTypeMerging,
         };
     }
     return {
@@ -1237,7 +1527,6 @@ function getDelegationContext({ request, schema, fieldName, returnType, args, in
         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) {
@@ -1278,22 +1567,59 @@ const createDefaultExecutor = utils.memoize1(function createDefaultExecutor(sche
     };
 });
 
+function isSubschemaConfig(value) {
+    return Boolean(value === null || value === void 0 ? void 0 : value.schema);
+}
+function cloneSubschemaConfig(subschemaConfig) {
+    var _a, _b;
+    const newSubschemaConfig = {
+        ...subschemaConfig,
+        transforms: subschemaConfig.transforms != null ? [...subschemaConfig.transforms] : undefined,
+    };
+    if (newSubschemaConfig.merge != null) {
+        newSubschemaConfig.merge = { ...subschemaConfig.merge };
+        for (const typeName in newSubschemaConfig.merge) {
+            const mergedTypeConfig = (newSubschemaConfig.merge[typeName] = { ...((_b = (_a = subschemaConfig.merge) === null || _a === void 0 ? void 0 : _a[typeName]) !== null && _b !== void 0 ? _b : {}) });
+            if (mergedTypeConfig.entryPoints != null) {
+                mergedTypeConfig.entryPoints = mergedTypeConfig.entryPoints.map(entryPoint => ({ ...entryPoint }));
+            }
+            if (mergedTypeConfig.fields != null) {
+                const fields = (mergedTypeConfig.fields = { ...mergedTypeConfig.fields });
+                for (const fieldName in fields) {
+                    fields[fieldName] = { ...fields[fieldName] };
+                }
+            }
+        }
+    }
+    return newSubschemaConfig;
+}
+
 exports.Subschema = Subschema;
 exports.Transformer = Transformer;
 exports.annotateExternalObject = annotateExternalObject;
 exports.applySchemaTransforms = applySchemaTransforms;
+exports.buildDelegationPlan = buildDelegationPlan;
 exports.cloneSubschemaConfig = cloneSubschemaConfig;
 exports.createDefaultExecutor = createDefaultExecutor;
+exports.createExternalValue = createExternalValue;
 exports.createRequest = createRequest;
 exports.createRequestFromInfo = createRequestFromInfo;
 exports.defaultMergedResolver = defaultMergedResolver;
 exports.delegateRequest = delegateRequest;
 exports.delegateToSchema = delegateToSchema;
+exports.externalValueFromResult = externalValueFromResult;
 exports.getDelegatingOperation = getDelegatingOperation;
+exports.getDelegationContext = getDelegationContext;
+exports.getExecutor = getExecutor;
+exports.getInfo = getInfo;
+exports.getInitialPath = getInitialPath;
+exports.getInitialPossibleFields = getInitialPossibleFields;
+exports.getMergedParent = getMergedParent;
+exports.getObjectSubchema = getObjectSubchema;
 exports.getSubschema = getSubschema;
+exports.getSubschemaMap = getSubschemaMap;
 exports.getUnpathedErrors = getUnpathedErrors;
 exports.isExternalObject = isExternalObject;
 exports.isSubschema = isSubschema;
 exports.isSubschemaConfig = isSubschemaConfig;
-exports.mergeFields = mergeFields;
-exports.resolveExternalValue = resolveExternalValue;
+exports.validateRequest = validateRequest;