@graphql-tools/delegate 12.0.20 → 12.1.0-alpha-cf04a323a695c2668e4b2edf5e8755dafaf41e8f

package/CHANGELOG.md

@@ -1,18 +1,45 @@
 # @graphql-tools/delegate
 
-## 12.0.20
-### Patch Changes
+## 12.1.0-alpha-cf04a323a695c2668e4b2edf5e8755dafaf41e8f
+### Minor Changes
 
 
 
-- [#2474](https://github.com/graphql-hive/gateway/pull/2474) [`8a08de3`](https://github.com/graphql-hive/gateway/commit/8a08de36be598f975ba500a28a9bd9710ead2d66) Thanks [@enisdenjo](https://github.com/enisdenjo)! - Fix delegated argument variable type compatibility
+- [#2473](https://github.com/graphql-hive/gateway/pull/2473) [`b42de25`](https://github.com/graphql-hive/gateway/commit/b42de25be0b656a0fbfe76f85f3cea287865184e) Thanks [@enisdenjo](https://github.com/enisdenjo)! - Introduce `resolveMergedTypeReference`, a helper that resolves plain objects returned by local resolvers through type merging
+  
+  When a resolver returns an object containing only the key fields of a merged type, the helper delegates just the missing requested fields to the owning subschema and returns a regular external object, so nested fields keep merging as usual. Fields the object already carries are never fetched again, and objects that already satisfy the request (or satisfy no merge key) are returned untouched.
+  
+  ```ts
+  // local resolver returns only the key
+  const payload = { id: '1' };
   
-  Avoid reusing variables whose types are incompatible with target schema argument types, and create correctly typed variables instead.
+  // client asks for { name surname } -> only `name` and `surname` are
+  // delegated to the subschema owning `Person`, `id` is kept as-is
+  resolveMergedTypeReference(payload, context, info);
+  ```
+
+### Patch Changes
 
 
-- [#2475](https://github.com/graphql-hive/gateway/pull/2475) [`65ce370`](https://github.com/graphql-hive/gateway/commit/65ce3702231068c946d4f95147b556cab57ad28c) Thanks [@enisdenjo](https://github.com/enisdenjo)! - Fix enum argument serialization when delegating to a field removed from the transformed schema.
+
+- [#2473](https://github.com/graphql-hive/gateway/pull/2473) [`b42de25`](https://github.com/graphql-hive/gateway/commit/b42de25be0b656a0fbfe76f85f3cea287865184e) Thanks [@enisdenjo](https://github.com/enisdenjo)! - `defaultMergedResolver` now falls back to the literal field name when an external object does not have the requested response key
+  
+  Plain resolver data merged into an external object is keyed by field name, so an aliased request used to resolve to `null` even though the value was there:
+  
+  ```graphql
+  {
+    person {
+      fullName: name
+    }
+  }
+  ```
+  
+  ```ts
+  // merged object carries resolver data by field name
+  { id: '1', name: 'Local' }
+  ```
   
-  When a delegated query field is filtered from the transformed schema, its arguments now use the original subschema for type lookup. This ensures enum values are sent as typed variables instead of invalid quoted enum literals while preserving input field transforms for fields that remain exposed.
+  Previously `fullName` was `null` because only the alias was looked up. Now it resolves to `'Local'` by field name, matching plain graphql-js behavior. When the response key is present (e.g. the field came from a subschema), it is still preferred.
 
 ## 12.0.19
 ### Patch Changes

package/dist/index.cjs

@@ -2354,18 +2354,10 @@ function createRequest({
       const existingArgNode = fieldNode?.arguments?.find(
         (argNode) => argNode.name.value === argName
       );
-      if (existingArgNode?.value.kind === graphql.Kind.VARIABLE && argInstance) {
+      if (existingArgNode?.value.kind === graphql.Kind.VARIABLE) {
         const varName = existingArgNode.value.name.value;
         const varValue = newVariables[varName];
-        const variableDefinition = variableDefinitions.find(
-          (definition) => definition.variable.name.value === varName
-        );
-        const variableType = variableDefinition && targetSchema ? graphql.typeFromAST(info?.schema ?? targetSchema, variableDefinition.type) : void 0;
-        if (varValue === argValue && variableType && graphql.isTypeSubTypeOf(
-          info?.schema ?? targetSchema,
-          variableType,
-          argInstance.type
-        )) {
+        if (varValue === argValue) {
           argNodes.push(existingArgNode);
           continue;
         }
@@ -2386,16 +2378,6 @@ function createRequest({
             varName = `_${i++}_${rootFieldName}_${argName}`;
           }
         }
-        if (existingArgNode?.value.kind === graphql.Kind.VARIABLE) {
-          const existingVarName = existingArgNode.value.name.value;
-          const existingVarIndex = variableDefinitions.findIndex(
-            (definition) => definition.variable.name.value === existingVarName
-          );
-          if (existingVarIndex !== -1) {
-            variableDefinitions.splice(existingVarIndex, 1);
-            delete newVariables[existingVarName];
-          }
-        }
         variableDefinitions.push({
           kind: graphql.Kind.VARIABLE_DEFINITION,
           variable: {
@@ -2567,6 +2549,9 @@ function defaultMergedResolver(parent, args, context, info) {
       }
       return deferred.promise;
     }
+    if (Object.prototype.hasOwnProperty.call(parent, info.fieldName)) {
+      return graphql.defaultFieldResolver(parent, args, context, info);
+    }
     return void 0;
   }
   return handleResult(parent, responseKey, context, info);
@@ -2995,7 +2980,7 @@ function delegateToSchema(options) {
   const request = createRequest({
     subgraphName: schema.name,
     fragments,
-    targetSchema: targetSchema.getQueryType()?.getFields()[fieldName] == null && isSubschemaConfig(schema) ? schema.schema : targetSchema,
+    targetSchema,
     rootValue,
     targetOperationName: operationName,
     targetOperation: operation,
@@ -3204,6 +3189,170 @@ function setObjectKeyPath(obj, path, value) {
   current[lastKey] = existingValue ? utils.mergeDeep([existingValue, value]) : value;
 }
 
+function valueSatisfiesSelectionSet(value, selectionSet) {
+  if (Array.isArray(value)) {
+    return value.every(
+      (item) => valueSatisfiesSelectionSet(item, selectionSet)
+    );
+  }
+  if (value == null || typeof value !== "object") {
+    return false;
+  }
+  return selectionSet.selections.every((selection) => {
+    if (selection.kind === graphql.Kind.INLINE_FRAGMENT) {
+      return valueSatisfiesSelectionSet(value, selection.selectionSet);
+    }
+    if (selection.kind !== graphql.Kind.FIELD) {
+      return false;
+    }
+    const responseKey = selection.alias?.value || selection.name.value;
+    return value[responseKey] !== void 0 && (selection.selectionSet == null || valueSatisfiesSelectionSet(value[responseKey], selection.selectionSet));
+  });
+}
+function resolveMergedTypeReference(result, context, info, stitchingInfo = info.schema.extensions?.["stitchingInfo"], providedFields) {
+  if (stitchingInfo == null || result == null) {
+    return result;
+  }
+  return resolveOne(result, context, info, stitchingInfo, providedFields);
+}
+function getMissingSelections(value, selections, fragments = {}) {
+  const missing = [];
+  for (const selection of selections) {
+    if (selection.kind === graphql.Kind.INLINE_FRAGMENT) {
+      const sub = getMissingSelections(
+        value,
+        selection.selectionSet.selections,
+        fragments
+      );
+      if (sub.length) {
+        missing.push({
+          ...selection,
+          selectionSet: { kind: graphql.Kind.SELECTION_SET, selections: sub }
+        });
+      }
+      continue;
+    }
+    if (selection.kind === graphql.Kind.FRAGMENT_SPREAD) {
+      const fragment = fragments[selection.name.value];
+      if (fragment == null) {
+        missing.push(selection);
+        continue;
+      }
+      const sub = getMissingSelections(
+        value,
+        fragment.selectionSet.selections,
+        fragments
+      );
+      if (sub.length) {
+        missing.push({
+          kind: graphql.Kind.INLINE_FRAGMENT,
+          typeCondition: fragment.typeCondition,
+          directives: [
+            ...fragment.directives ?? [],
+            ...selection.directives ?? []
+          ],
+          selectionSet: { kind: graphql.Kind.SELECTION_SET, selections: sub }
+        });
+      }
+      continue;
+    }
+    const fieldValue = value[selection.name.value];
+    if (fieldValue === void 0 || fieldValue === null && selection.selectionSet != null) {
+      missing.push(selection);
+      continue;
+    }
+    if (selection.selectionSet != null) {
+      if (Array.isArray(fieldValue)) {
+        const anyMissing = fieldValue.some(
+          (item) => getMissingSelections(
+            item,
+            selection.selectionSet.selections,
+            fragments
+          ).length > 0
+        );
+        if (anyMissing) {
+          missing.push(selection);
+        }
+      } else {
+        const sub = getMissingSelections(
+          fieldValue,
+          selection.selectionSet.selections,
+          fragments
+        );
+        if (sub.length) {
+          missing.push({
+            ...selection,
+            selectionSet: { kind: graphql.Kind.SELECTION_SET, selections: sub }
+          });
+        }
+      }
+    }
+  }
+  return missing;
+}
+function resolveOne(value, context, info, stitchingInfo, providedFields) {
+  if (Array.isArray(value)) {
+    return value.map(
+      (item) => resolveOne(item, context, info, stitchingInfo, providedFields)
+    );
+  }
+  if (value == null || typeof value !== "object" || value instanceof Error || isExternalObject(value)) {
+    return value;
+  }
+  const returnType = graphql.getNamedType(info.returnType);
+  const typeName = value["__typename"] ?? returnType.name;
+  const mergedTypeInfo = stitchingInfo.mergedTypes[typeName];
+  if (mergedTypeInfo == null) {
+    return value;
+  }
+  let selections = info.fieldNodes.flatMap(
+    (fieldNode) => fieldNode.selectionSet?.selections ?? []
+  );
+  if (providedFields?.size) {
+    selections = selections.filter(
+      (selection) => selection.kind !== graphql.Kind.FIELD || !providedFields.has(selection.name.value)
+    );
+  }
+  const missingSelections = getMissingSelections(
+    value,
+    selections,
+    info.fragments
+  );
+  if (!missingSelections.length) {
+    return value;
+  }
+  const selectionSet = {
+    kind: graphql.Kind.SELECTION_SET,
+    selections: missingSelections
+  };
+  for (const [subschema, keySelectionSet] of mergedTypeInfo.selectionSets) {
+    if (valueSatisfiesSelectionSet(value, keySelectionSet)) {
+      const resolver = mergedTypeInfo.resolvers.get(subschema);
+      if (resolver != null) {
+        if (value["__typename"] == null && !graphql.isAbstractType(returnType)) {
+          value["__typename"] = typeName;
+        }
+        return promiseHelpers.handleMaybePromise(
+          () => resolver(
+            value,
+            context,
+            info,
+            subschema,
+            selectionSet,
+            void 0,
+            returnType
+          ),
+          // value comes first so the delegation result wins on overlaps, while
+          // payload fields outside the delegated selection (like the key) survive;
+          // respectNonEnumerableSymbols keeps the external object annotation intact
+          (resolved) => utils.mergeDeep([value, resolved], false, false, false, true)
+        );
+      }
+    }
+  }
+  return value;
+}
+
 function extractUnavailableFieldsFromSelectionSet(schema, fieldType, fieldSelectionSet, shouldAdd, fragments = {}) {
   if (graphql.isLeafType(fieldType)) {
     return [];
@@ -3505,4 +3654,5 @@ exports.isSubschemaConfig = isSubschemaConfig;
 exports.leftOverByDelegationPlan = leftOverByDelegationPlan;
 exports.mergeFields = mergeFields;
 exports.resolveExternalValue = resolveExternalValue;
+exports.resolveMergedTypeReference = resolveMergedTypeReference;
 exports.subtractSelectionSets = subtractSelectionSets;

package/dist/index.d.cts

@@ -187,6 +187,8 @@ declare function createRequest({ subgraphName, fragments, rootValue, targetOpera
  * a) handle aliases for proxied schemas
  * b) handle errors from proxied schemas
  * c) handle external to internal enum conversion
+ * d) fall back to the field name for plain resolver data merged into
+ *    external objects, which is keyed by literal field name
  */
 declare function defaultMergedResolver(parent: ExternalObject, args: Record<string, any>, context: Record<string, any>, info: GraphQLResolveInfo): any;
 
@@ -205,6 +207,38 @@ declare function handleResolverResult(resolverResult: any, subschema: Subschema,
 
 declare function resolveExternalValue<TContext extends Record<string, any>>(result: any, unpathedErrors: Array<GraphQLError>, subschema: GraphQLSchema | SubschemaConfig<any, any, any, TContext>, context?: Record<string, any>, info?: GraphQLResolveInfo, returnType?: GraphQLOutputType, skipTypeMerging?: boolean): any;
 
+/**
+ * Takes a plain object produced by a local resolver and resolves it through
+ * type merging when needed:
+ *
+ * - If the object already satisfies the requested selection set, it is
+ *   returned as-is and no delegation happens. This is the fast path for
+ *   resolvers that return complete values.
+ * - If requested fields are missing but the object satisfies a merge key of
+ *   the return type, only the missing fields are delegated to the owning
+ *   subschema. The merge key is only the entry ticket; fields the object
+ *   already carries are kept as-is and never fetched from the subschema, and
+ *   the merged result keeps merging nested fields through the usual
+ *   stitching flow.
+ * - Payloads are raw resolver results keyed by literal field name, so
+ *   aliased requests are matched by field name and aliased fields already in
+ *   the payload are not fetched again. Hydrated results carry only literal
+ *   field names; `defaultMergedResolver` falls back to the field name when
+ *   the aliased response key is absent, so incoming query aliases resolve
+ *   with plain graphql-js semantics.
+ * - When merge keys of several subschemas are satisfied, the first match
+ *   wins. Any match works because the delegation is pruned to the fields the
+ *   chosen subschema provides, and nested merging covers the rest.
+ * - Fields listed in `providedFields` (fields that have their own resolver on
+ *   the stitched schema) are excluded from the required selection, because
+ *   they are resolved locally anyway. When the remaining selection is already
+ *   satisfied by the object, no delegation happens at all.
+ * - Objects that satisfy no merge key, are already external, or are not
+ *   objects at all are returned untouched, so missing non-nullable fields
+ *   error downstream exactly as they would without this helper.
+ */
+declare function resolveMergedTypeReference<TContext extends Record<string, any> = Record<string, any>>(result: any, context: TContext, info: GraphQLResolveInfo, stitchingInfo?: StitchingInfo<TContext>, providedFields?: ReadonlySet<string>): any;
+
 declare function isSubschemaConfig(value: any): value is SubschemaConfig<any, any, any, any>;
 declare function cloneSubschemaConfig(subschemaConfig: SubschemaConfig): SubschemaConfig;
 
@@ -237,4 +271,4 @@ declare function isPrototypePollutingKey(key: string): key is PrototypePolluting
 
 declare const handleOverrideByDelegation: (info: GraphQLResolveInfo$1, context: any, overrideHandler: OverrideHandler) => boolean;
 
-export { type BatchingOptions, type CreateProxyingResolverFn, type Deferred, type DelegationContext, type DelegationPlanBuilder, type DelegationPlanLeftOver, EMPTY_ARRAY, EMPTY_OBJECT, type ExternalObject, FIELD_SUBSCHEMA_MAP_SYMBOL, type ICreateProxyingResolverOptions, type ICreateRequest, type IDelegateRequestOptions, type IDelegateToSchemaOptions, type MergedFieldConfig, type MergedTypeConfig, type MergedTypeEntryPoint, type MergedTypeInfo, type MergedTypeResolver, type MergedTypeResolverOptions, OBJECT_SUBSCHEMA_SYMBOL, type OverrideHandler, PLAN_LEFT_OVER, type RequestTransform, type ResultTransform, type SchemaTransform, type StitchingInfo, Subschema, type SubschemaConfig, type Transform, Transformer, UNPATHED_ERRORS_SYMBOL, annotateExternalObject, applySchemaTransforms, cloneSubschemaConfig, createRequest, defaultMergedResolver, delegateRequest, delegateToSchema, extractUnavailableFields, extractUnavailableFieldsFromSelectionSet, getActualFieldNodes, getDelegatingOperation, getPlanLeftOverFromParent, getSubschema, getTypeInfo, getTypeInfoWithType, getUnpathedErrors, handleOverrideByDelegation, handleResolverResult, isExternalObject, isPrototypePollutingKey, isSubschema, isSubschemaConfig, leftOverByDelegationPlan, mergeFields, resolveExternalValue, subtractSelectionSets };
+export { type BatchingOptions, type CreateProxyingResolverFn, type Deferred, type DelegationContext, type DelegationPlanBuilder, type DelegationPlanLeftOver, EMPTY_ARRAY, EMPTY_OBJECT, type ExternalObject, FIELD_SUBSCHEMA_MAP_SYMBOL, type ICreateProxyingResolverOptions, type ICreateRequest, type IDelegateRequestOptions, type IDelegateToSchemaOptions, type MergedFieldConfig, type MergedTypeConfig, type MergedTypeEntryPoint, type MergedTypeInfo, type MergedTypeResolver, type MergedTypeResolverOptions, OBJECT_SUBSCHEMA_SYMBOL, type OverrideHandler, PLAN_LEFT_OVER, type RequestTransform, type ResultTransform, type SchemaTransform, type StitchingInfo, Subschema, type SubschemaConfig, type Transform, Transformer, UNPATHED_ERRORS_SYMBOL, annotateExternalObject, applySchemaTransforms, cloneSubschemaConfig, createRequest, defaultMergedResolver, delegateRequest, delegateToSchema, extractUnavailableFields, extractUnavailableFieldsFromSelectionSet, getActualFieldNodes, getDelegatingOperation, getPlanLeftOverFromParent, getSubschema, getTypeInfo, getTypeInfoWithType, getUnpathedErrors, handleOverrideByDelegation, handleResolverResult, isExternalObject, isPrototypePollutingKey, isSubschema, isSubschemaConfig, leftOverByDelegationPlan, mergeFields, resolveExternalValue, resolveMergedTypeReference, subtractSelectionSets };

package/dist/index.d.ts

@@ -187,6 +187,8 @@ declare function createRequest({ subgraphName, fragments, rootValue, targetOpera
  * a) handle aliases for proxied schemas
  * b) handle errors from proxied schemas
  * c) handle external to internal enum conversion
+ * d) fall back to the field name for plain resolver data merged into
+ *    external objects, which is keyed by literal field name
  */
 declare function defaultMergedResolver(parent: ExternalObject, args: Record<string, any>, context: Record<string, any>, info: GraphQLResolveInfo): any;
 
@@ -205,6 +207,38 @@ declare function handleResolverResult(resolverResult: any, subschema: Subschema,
 
 declare function resolveExternalValue<TContext extends Record<string, any>>(result: any, unpathedErrors: Array<GraphQLError>, subschema: GraphQLSchema | SubschemaConfig<any, any, any, TContext>, context?: Record<string, any>, info?: GraphQLResolveInfo, returnType?: GraphQLOutputType, skipTypeMerging?: boolean): any;
 
+/**
+ * Takes a plain object produced by a local resolver and resolves it through
+ * type merging when needed:
+ *
+ * - If the object already satisfies the requested selection set, it is
+ *   returned as-is and no delegation happens. This is the fast path for
+ *   resolvers that return complete values.
+ * - If requested fields are missing but the object satisfies a merge key of
+ *   the return type, only the missing fields are delegated to the owning
+ *   subschema. The merge key is only the entry ticket; fields the object
+ *   already carries are kept as-is and never fetched from the subschema, and
+ *   the merged result keeps merging nested fields through the usual
+ *   stitching flow.
+ * - Payloads are raw resolver results keyed by literal field name, so
+ *   aliased requests are matched by field name and aliased fields already in
+ *   the payload are not fetched again. Hydrated results carry only literal
+ *   field names; `defaultMergedResolver` falls back to the field name when
+ *   the aliased response key is absent, so incoming query aliases resolve
+ *   with plain graphql-js semantics.
+ * - When merge keys of several subschemas are satisfied, the first match
+ *   wins. Any match works because the delegation is pruned to the fields the
+ *   chosen subschema provides, and nested merging covers the rest.
+ * - Fields listed in `providedFields` (fields that have their own resolver on
+ *   the stitched schema) are excluded from the required selection, because
+ *   they are resolved locally anyway. When the remaining selection is already
+ *   satisfied by the object, no delegation happens at all.
+ * - Objects that satisfy no merge key, are already external, or are not
+ *   objects at all are returned untouched, so missing non-nullable fields
+ *   error downstream exactly as they would without this helper.
+ */
+declare function resolveMergedTypeReference<TContext extends Record<string, any> = Record<string, any>>(result: any, context: TContext, info: GraphQLResolveInfo, stitchingInfo?: StitchingInfo<TContext>, providedFields?: ReadonlySet<string>): any;
+
 declare function isSubschemaConfig(value: any): value is SubschemaConfig<any, any, any, any>;
 declare function cloneSubschemaConfig(subschemaConfig: SubschemaConfig): SubschemaConfig;
 
@@ -237,4 +271,4 @@ declare function isPrototypePollutingKey(key: string): key is PrototypePolluting
 
 declare const handleOverrideByDelegation: (info: GraphQLResolveInfo$1, context: any, overrideHandler: OverrideHandler) => boolean;
 
-export { type BatchingOptions, type CreateProxyingResolverFn, type Deferred, type DelegationContext, type DelegationPlanBuilder, type DelegationPlanLeftOver, EMPTY_ARRAY, EMPTY_OBJECT, type ExternalObject, FIELD_SUBSCHEMA_MAP_SYMBOL, type ICreateProxyingResolverOptions, type ICreateRequest, type IDelegateRequestOptions, type IDelegateToSchemaOptions, type MergedFieldConfig, type MergedTypeConfig, type MergedTypeEntryPoint, type MergedTypeInfo, type MergedTypeResolver, type MergedTypeResolverOptions, OBJECT_SUBSCHEMA_SYMBOL, type OverrideHandler, PLAN_LEFT_OVER, type RequestTransform, type ResultTransform, type SchemaTransform, type StitchingInfo, Subschema, type SubschemaConfig, type Transform, Transformer, UNPATHED_ERRORS_SYMBOL, annotateExternalObject, applySchemaTransforms, cloneSubschemaConfig, createRequest, defaultMergedResolver, delegateRequest, delegateToSchema, extractUnavailableFields, extractUnavailableFieldsFromSelectionSet, getActualFieldNodes, getDelegatingOperation, getPlanLeftOverFromParent, getSubschema, getTypeInfo, getTypeInfoWithType, getUnpathedErrors, handleOverrideByDelegation, handleResolverResult, isExternalObject, isPrototypePollutingKey, isSubschema, isSubschemaConfig, leftOverByDelegationPlan, mergeFields, resolveExternalValue, subtractSelectionSets };
+export { type BatchingOptions, type CreateProxyingResolverFn, type Deferred, type DelegationContext, type DelegationPlanBuilder, type DelegationPlanLeftOver, EMPTY_ARRAY, EMPTY_OBJECT, type ExternalObject, FIELD_SUBSCHEMA_MAP_SYMBOL, type ICreateProxyingResolverOptions, type ICreateRequest, type IDelegateRequestOptions, type IDelegateToSchemaOptions, type MergedFieldConfig, type MergedTypeConfig, type MergedTypeEntryPoint, type MergedTypeInfo, type MergedTypeResolver, type MergedTypeResolverOptions, OBJECT_SUBSCHEMA_SYMBOL, type OverrideHandler, PLAN_LEFT_OVER, type RequestTransform, type ResultTransform, type SchemaTransform, type StitchingInfo, Subschema, type SubschemaConfig, type Transform, Transformer, UNPATHED_ERRORS_SYMBOL, annotateExternalObject, applySchemaTransforms, cloneSubschemaConfig, createRequest, defaultMergedResolver, delegateRequest, delegateToSchema, extractUnavailableFields, extractUnavailableFieldsFromSelectionSet, getActualFieldNodes, getDelegatingOperation, getPlanLeftOverFromParent, getSubschema, getTypeInfo, getTypeInfoWithType, getUnpathedErrors, handleOverrideByDelegation, handleResolverResult, isExternalObject, isPrototypePollutingKey, isSubschema, isSubschemaConfig, leftOverByDelegationPlan, mergeFields, resolveExternalValue, resolveMergedTypeReference, subtractSelectionSets };

package/dist/index.js

@@ -1,6 +1,6 @@
 import { memoize2, memoize1, collectFields, relocatedError, mergeDeep, promiseReduce, pathToArray, getResponseKeyFromInfo, memoize3, getDefinedRootType, createGraphQLError, implementsAbstractType, getRootTypeNames, astFromArg, astFromValueUntyped, asArray, isAsyncIterable, getOperationASTFromRequest } from '@graphql-tools/utils';
 export { createDeferred } from '@graphql-tools/utils';
-import { GraphQLError, locatedError, isAbstractType, getNullableType, isLeafType, isCompositeType, isListType, responsePathAsArray, Kind, TypeInfo, versionInfo, visit, visitWithTypeInfo, isNullableType, isUnionType, getNamedType, isObjectType, isInterfaceType, typeFromAST, isTypeSubTypeOf, isNonNullType, isInputObjectType, defaultFieldResolver, isSchema, validate } from 'graphql';
+import { GraphQLError, locatedError, isAbstractType, getNullableType, isLeafType, isCompositeType, isListType, responsePathAsArray, Kind, TypeInfo, versionInfo, visit, visitWithTypeInfo, isNullableType, isUnionType, getNamedType, isObjectType, isInterfaceType, isNonNullType, isInputObjectType, defaultFieldResolver, isSchema, validate } from 'graphql';
 import { handleMaybePromise, isPromise, createDeferredPromise, mapAsyncIterator } from '@whatwg-node/promise-helpers';
 import { CRITICAL_ERROR, executorFromSchema } from '@graphql-tools/executor';
 export { executorFromSchema as createDefaultExecutor } from '@graphql-tools/executor';
@@ -2354,18 +2354,10 @@ function createRequest({
       const existingArgNode = fieldNode?.arguments?.find(
         (argNode) => argNode.name.value === argName
       );
-      if (existingArgNode?.value.kind === Kind.VARIABLE && argInstance) {
+      if (existingArgNode?.value.kind === Kind.VARIABLE) {
         const varName = existingArgNode.value.name.value;
         const varValue = newVariables[varName];
-        const variableDefinition = variableDefinitions.find(
-          (definition) => definition.variable.name.value === varName
-        );
-        const variableType = variableDefinition && targetSchema ? typeFromAST(info?.schema ?? targetSchema, variableDefinition.type) : void 0;
-        if (varValue === argValue && variableType && isTypeSubTypeOf(
-          info?.schema ?? targetSchema,
-          variableType,
-          argInstance.type
-        )) {
+        if (varValue === argValue) {
           argNodes.push(existingArgNode);
           continue;
         }
@@ -2386,16 +2378,6 @@ function createRequest({
             varName = `_${i++}_${rootFieldName}_${argName}`;
           }
         }
-        if (existingArgNode?.value.kind === Kind.VARIABLE) {
-          const existingVarName = existingArgNode.value.name.value;
-          const existingVarIndex = variableDefinitions.findIndex(
-            (definition) => definition.variable.name.value === existingVarName
-          );
-          if (existingVarIndex !== -1) {
-            variableDefinitions.splice(existingVarIndex, 1);
-            delete newVariables[existingVarName];
-          }
-        }
         variableDefinitions.push({
           kind: Kind.VARIABLE_DEFINITION,
           variable: {
@@ -2567,6 +2549,9 @@ function defaultMergedResolver(parent, args, context, info) {
       }
       return deferred.promise;
     }
+    if (Object.prototype.hasOwnProperty.call(parent, info.fieldName)) {
+      return defaultFieldResolver(parent, args, context, info);
+    }
     return void 0;
   }
   return handleResult(parent, responseKey, context, info);
@@ -2995,7 +2980,7 @@ function delegateToSchema(options) {
   const request = createRequest({
     subgraphName: schema.name,
     fragments,
-    targetSchema: targetSchema.getQueryType()?.getFields()[fieldName] == null && isSubschemaConfig(schema) ? schema.schema : targetSchema,
+    targetSchema,
     rootValue,
     targetOperationName: operationName,
     targetOperation: operation,
@@ -3204,6 +3189,170 @@ function setObjectKeyPath(obj, path, value) {
   current[lastKey] = existingValue ? mergeDeep([existingValue, value]) : value;
 }
 
+function valueSatisfiesSelectionSet(value, selectionSet) {
+  if (Array.isArray(value)) {
+    return value.every(
+      (item) => valueSatisfiesSelectionSet(item, selectionSet)
+    );
+  }
+  if (value == null || typeof value !== "object") {
+    return false;
+  }
+  return selectionSet.selections.every((selection) => {
+    if (selection.kind === Kind.INLINE_FRAGMENT) {
+      return valueSatisfiesSelectionSet(value, selection.selectionSet);
+    }
+    if (selection.kind !== Kind.FIELD) {
+      return false;
+    }
+    const responseKey = selection.alias?.value || selection.name.value;
+    return value[responseKey] !== void 0 && (selection.selectionSet == null || valueSatisfiesSelectionSet(value[responseKey], selection.selectionSet));
+  });
+}
+function resolveMergedTypeReference(result, context, info, stitchingInfo = info.schema.extensions?.["stitchingInfo"], providedFields) {
+  if (stitchingInfo == null || result == null) {
+    return result;
+  }
+  return resolveOne(result, context, info, stitchingInfo, providedFields);
+}
+function getMissingSelections(value, selections, fragments = {}) {
+  const missing = [];
+  for (const selection of selections) {
+    if (selection.kind === Kind.INLINE_FRAGMENT) {
+      const sub = getMissingSelections(
+        value,
+        selection.selectionSet.selections,
+        fragments
+      );
+      if (sub.length) {
+        missing.push({
+          ...selection,
+          selectionSet: { kind: Kind.SELECTION_SET, selections: sub }
+        });
+      }
+      continue;
+    }
+    if (selection.kind === Kind.FRAGMENT_SPREAD) {
+      const fragment = fragments[selection.name.value];
+      if (fragment == null) {
+        missing.push(selection);
+        continue;
+      }
+      const sub = getMissingSelections(
+        value,
+        fragment.selectionSet.selections,
+        fragments
+      );
+      if (sub.length) {
+        missing.push({
+          kind: Kind.INLINE_FRAGMENT,
+          typeCondition: fragment.typeCondition,
+          directives: [
+            ...fragment.directives ?? [],
+            ...selection.directives ?? []
+          ],
+          selectionSet: { kind: Kind.SELECTION_SET, selections: sub }
+        });
+      }
+      continue;
+    }
+    const fieldValue = value[selection.name.value];
+    if (fieldValue === void 0 || fieldValue === null && selection.selectionSet != null) {
+      missing.push(selection);
+      continue;
+    }
+    if (selection.selectionSet != null) {
+      if (Array.isArray(fieldValue)) {
+        const anyMissing = fieldValue.some(
+          (item) => getMissingSelections(
+            item,
+            selection.selectionSet.selections,
+            fragments
+          ).length > 0
+        );
+        if (anyMissing) {
+          missing.push(selection);
+        }
+      } else {
+        const sub = getMissingSelections(
+          fieldValue,
+          selection.selectionSet.selections,
+          fragments
+        );
+        if (sub.length) {
+          missing.push({
+            ...selection,
+            selectionSet: { kind: Kind.SELECTION_SET, selections: sub }
+          });
+        }
+      }
+    }
+  }
+  return missing;
+}
+function resolveOne(value, context, info, stitchingInfo, providedFields) {
+  if (Array.isArray(value)) {
+    return value.map(
+      (item) => resolveOne(item, context, info, stitchingInfo, providedFields)
+    );
+  }
+  if (value == null || typeof value !== "object" || value instanceof Error || isExternalObject(value)) {
+    return value;
+  }
+  const returnType = getNamedType(info.returnType);
+  const typeName = value["__typename"] ?? returnType.name;
+  const mergedTypeInfo = stitchingInfo.mergedTypes[typeName];
+  if (mergedTypeInfo == null) {
+    return value;
+  }
+  let selections = info.fieldNodes.flatMap(
+    (fieldNode) => fieldNode.selectionSet?.selections ?? []
+  );
+  if (providedFields?.size) {
+    selections = selections.filter(
+      (selection) => selection.kind !== Kind.FIELD || !providedFields.has(selection.name.value)
+    );
+  }
+  const missingSelections = getMissingSelections(
+    value,
+    selections,
+    info.fragments
+  );
+  if (!missingSelections.length) {
+    return value;
+  }
+  const selectionSet = {
+    kind: Kind.SELECTION_SET,
+    selections: missingSelections
+  };
+  for (const [subschema, keySelectionSet] of mergedTypeInfo.selectionSets) {
+    if (valueSatisfiesSelectionSet(value, keySelectionSet)) {
+      const resolver = mergedTypeInfo.resolvers.get(subschema);
+      if (resolver != null) {
+        if (value["__typename"] == null && !isAbstractType(returnType)) {
+          value["__typename"] = typeName;
+        }
+        return handleMaybePromise(
+          () => resolver(
+            value,
+            context,
+            info,
+            subschema,
+            selectionSet,
+            void 0,
+            returnType
+          ),
+          // value comes first so the delegation result wins on overlaps, while
+          // payload fields outside the delegated selection (like the key) survive;
+          // respectNonEnumerableSymbols keeps the external object annotation intact
+          (resolved) => mergeDeep([value, resolved], false, false, false, true)
+        );
+      }
+    }
+  }
+  return value;
+}
+
 function extractUnavailableFieldsFromSelectionSet(schema, fieldType, fieldSelectionSet, shouldAdd, fragments = {}) {
   if (isLeafType(fieldType)) {
     return [];
@@ -3464,4 +3613,4 @@ function subtractSelectionSets(selectionSetA, selectionSetB, fragments = {}) {
   };
 }
 
-export { EMPTY_ARRAY, EMPTY_OBJECT, FIELD_SUBSCHEMA_MAP_SYMBOL, OBJECT_SUBSCHEMA_SYMBOL, PLAN_LEFT_OVER, Subschema, Transformer, UNPATHED_ERRORS_SYMBOL, annotateExternalObject, applySchemaTransforms, cloneSubschemaConfig, createRequest, defaultMergedResolver, delegateRequest, delegateToSchema, extractUnavailableFields, extractUnavailableFieldsFromSelectionSet, getActualFieldNodes, getDelegatingOperation, getPlanLeftOverFromParent, getSubschema, getTypeInfo, getTypeInfoWithType, getUnpathedErrors, handleOverrideByDelegation, handleResolverResult, isExternalObject, isPrototypePollutingKey, isSubschema, isSubschemaConfig, leftOverByDelegationPlan, mergeFields, resolveExternalValue, subtractSelectionSets };
+export { EMPTY_ARRAY, EMPTY_OBJECT, FIELD_SUBSCHEMA_MAP_SYMBOL, OBJECT_SUBSCHEMA_SYMBOL, PLAN_LEFT_OVER, Subschema, Transformer, UNPATHED_ERRORS_SYMBOL, annotateExternalObject, applySchemaTransforms, cloneSubschemaConfig, createRequest, defaultMergedResolver, delegateRequest, delegateToSchema, extractUnavailableFields, extractUnavailableFieldsFromSelectionSet, getActualFieldNodes, getDelegatingOperation, getPlanLeftOverFromParent, getSubschema, getTypeInfo, getTypeInfoWithType, getUnpathedErrors, handleOverrideByDelegation, handleResolverResult, isExternalObject, isPrototypePollutingKey, isSubschema, isSubschemaConfig, leftOverByDelegationPlan, mergeFields, resolveExternalValue, resolveMergedTypeReference, subtractSelectionSets };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphql-tools/delegate",
-  "version": "12.0.20",
+  "version": "12.1.0-alpha-cf04a323a695c2668e4b2edf5e8755dafaf41e8f",
   "type": "module",
   "description": "A set of utils for faster development of GraphQL tools",
   "repository": {