@graphql-hive/router-runtime 1.2.5 → 1.3.0-alpha-a990d4c23ad5a2cd3bc5526ee8a987fa39a5ca86

package/CHANGELOG.md

@@ -1,6 +1,13 @@
 # @graphql-hive/router-runtime
 
-## 1.2.5
+## 1.3.0-alpha-a990d4c23ad5a2cd3bc5526ee8a987fa39a5ca86
+### Minor Changes
+
+
+
+- [#2203](https://github.com/graphql-hive/gateway/pull/2203) [`12dfc58`](https://github.com/graphql-hive/gateway/commit/12dfc58cf08fcfb7e47a0a000f36f846701a05e1) Thanks [@ardatan](https://github.com/ardatan)! - EDFS Support for Router Runtime
+
+
 ### Patch Changes
 
 

package/dist/index.cjs

@@ -10,6 +10,219 @@ var graphql = require('graphql');
 var core = require('@envelop/core');
 var executor = require('@graphql-tools/executor');
 
+const getTypeInfo = utils.memoize1(function getTypeInfo2(schema) {
+  return new graphql.TypeInfo(schema);
+});
+utils.memoize2(function getTypeInfoWithType2(schema, type) {
+  return graphql.versionInfo.major < 16 ? new graphql.TypeInfo(schema, void 0, type) : new graphql.TypeInfo(schema, type);
+});
+
+const getPubsubOperationRootFields = utils.memoize1(function(schema) {
+  const pubsubOperationFields = /* @__PURE__ */ new Map();
+  const subscriptionType = schema.getSubscriptionType();
+  if (subscriptionType) {
+    const subscriptionFields = subscriptionType.getFields();
+    for (const fieldName in subscriptionFields) {
+      const fieldDef = subscriptionFields[fieldName];
+      if (fieldDef) {
+        const pubsubOperations = utils.getDirectiveInExtensions(
+          fieldDef,
+          "pubsubOperation"
+        );
+        if (pubsubOperations) {
+          for (const { pubsubTopic } of pubsubOperations) {
+            pubsubOperationFields.set(fieldDef.name, pubsubTopic);
+          }
+        }
+      }
+    }
+  }
+  return pubsubOperationFields;
+});
+function resolvePubsubOperationRootField(responseKey, topicName, pubsub) {
+  return utils.mapAsyncIterator(pubsub.subscribe(topicName), (payload) => ({
+    data: {
+      [responseKey]: payload
+    }
+  }));
+}
+function handlePubsubOperationField(supergraphSchema, executionRequest) {
+  if (executionRequest.operationType === "subscription") {
+    const typeInfo = getTypeInfo(supergraphSchema);
+    let responseKey;
+    let fieldName;
+    let selectionSet;
+    let returnType;
+    graphql.visit(
+      executionRequest.document,
+      graphql.visitWithTypeInfo(typeInfo, {
+        Field(node) {
+          const parentType = typeInfo.getParentType();
+          if (parentType === supergraphSchema.getSubscriptionType()) {
+            responseKey = node.alias?.value || node.name.value;
+            fieldName = node.name.value;
+            selectionSet = node.selectionSet;
+            const fieldDef = typeInfo.getFieldDef();
+            if (fieldDef) {
+              returnType = graphql.getNamedType(fieldDef.type);
+            }
+            return graphql.BREAK;
+          }
+          return node;
+        }
+      })
+    );
+    if (responseKey && fieldName) {
+      const pubsubOperationFields = getPubsubOperationRootFields(supergraphSchema);
+      const pubsubTopic = pubsubOperationFields.get(fieldName);
+      if (pubsubTopic) {
+        const pubsub = executionRequest.context?.pubsub;
+        if (!pubsub) {
+          throw utils.createGraphQLError(
+            `You have to configure a PubSub instance in the context to execute subscription operations with @pubsubOperation directive.`
+          );
+        }
+        let newExecutionRequest;
+        if (selectionSet && returnType) {
+          const newDocument = graphql.parse(
+            /* GraphQL */
+            `
+                query ${executionRequest.operationName}($representations: [_Any!]!) {
+                    _entities(representations: $representations) {
+                        __typename
+                        ... on ${returnType.name} ${graphql.print(selectionSet)}
+                    }
+                } 
+            `
+          );
+          newExecutionRequest = {
+            ...executionRequest,
+            document: newDocument
+          };
+        }
+        return {
+          executionResult: resolvePubsubOperationRootField(
+            responseKey,
+            pubsubTopic,
+            pubsub
+          ),
+          responseKey,
+          returnTypeName: returnType?.name,
+          newExecutionRequest
+        };
+      }
+    }
+  }
+  return false;
+}
+const getPubsubPublishVisitor = utils.memoize2(function getPubsubPublishFields(schema, pubsub) {
+  const pubsubPublishVisitor = {};
+  for (const typeName in schema.getTypeMap()) {
+    const type = schema.getType(typeName);
+    if (type != null && "getFields" in type) {
+      const fields = type.getFields();
+      for (const fieldName in fields) {
+        const fieldDef = fields[fieldName];
+        if (fieldDef) {
+          const pubsubPublishes = utils.getDirectiveInExtensions(
+            fieldDef,
+            "pubsubPublish"
+          );
+          if (pubsubPublishes) {
+            for (const { pubsubTopic } of pubsubPublishes) {
+              const typeVisitor = pubsubPublishVisitor[typeName] ||= {};
+              typeVisitor[fieldName] = (value) => {
+                pubsub.publish(pubsubTopic, value);
+                return value;
+              };
+            }
+          }
+        }
+      }
+    }
+  }
+  if (!Object.keys(pubsubPublishVisitor).length) {
+    return false;
+  }
+  return pubsubPublishVisitor;
+});
+function handleResultWithPubSubPublish(schema, request, result) {
+  if (result.data != null && request.context?.pubsub != null) {
+    const pubsubPublishVisitor = getPubsubPublishVisitor(
+      schema,
+      request.context.pubsub
+    );
+    if (pubsubPublishVisitor) {
+      return utils.visitResult(result, request, schema, pubsubPublishVisitor);
+    }
+  }
+}
+
+const queryPlanForExecutionRequestContext = /* @__PURE__ */ new WeakMap();
+function getLazyValue(factory) {
+  let _value;
+  return function() {
+    if (_value == null) {
+      _value = factory();
+    }
+    return _value;
+  };
+}
+function getLazyFactory(factory) {
+  let _value;
+  return function(...args) {
+    if (!_value) {
+      _value = factory();
+    }
+    return _value(...args);
+  };
+}
+function onSubgraphExecuteWithTransforms(subgraphName, executionRequest, onSubgraphExecute, getSubschema) {
+  const subschema = getSubschema(subgraphName);
+  if (subschema.transforms?.length) {
+    const transforms = subschema.transforms;
+    const transformationContext = /* @__PURE__ */ Object.create(null);
+    const delegationContext = void 0;
+    for (const transform of transforms) {
+      if (transform.transformRequest) {
+        executionRequest = transform.transformRequest(
+          executionRequest,
+          delegationContext,
+          transformationContext
+        );
+      }
+    }
+    return handleMaybePromiseMaybeAsyncIterable(
+      () => onSubgraphExecute(subgraphName, executionRequest),
+      (executionResult) => {
+        for (const transform of transforms.toReversed()) {
+          if (transform.transformResult) {
+            executionResult = transform.transformResult(
+              executionResult,
+              delegationContext,
+              transformationContext
+            );
+          }
+        }
+        return executionResult;
+      }
+    );
+  }
+  return onSubgraphExecute(subgraphName, executionRequest);
+}
+function handleMaybePromiseMaybeAsyncIterable(executor, mapper, errorMapper) {
+  return promiseHelpers.handleMaybePromise(
+    executor,
+    (result$) => {
+      if (utils.isAsyncIterable(result$)) {
+        return promiseHelpers.mapAsyncIterator(result$, mapper, errorMapper);
+      }
+      return mapper(result$);
+    },
+    errorMapper
+  );
+}
+
 function isEntityRepresentation(obj) {
   return obj?.__typename != null;
 }
@@ -28,23 +241,17 @@ function executeQueryPlan({
     executionRequest,
     onSubgraphExecute
   });
-  function handleResp() {
-    const executionResult = {};
-    if (Object.keys(executionContext.data).length > 0) {
-      executionResult.data = projectDataByOperation(executionContext);
-    }
-    if (executionContext.errors.length > 0) {
-      executionResult.errors = executionContext.errors;
-    }
-    return executionResult;
-  }
-  return promiseHelpers.handleMaybePromise(
+  return handleMaybePromiseMaybeAsyncIterable(
     () => executePlanNode(node, executionContext),
-    (res) => {
-      if (utils.isAsyncIterable(res)) {
-        return promiseHelpers.mapAsyncIterator(res, handleResp);
+    () => {
+      const executionResult = {};
+      if (Object.keys(executionContext.data).length > 0) {
+        executionResult.data = projectDataByOperation(executionContext);
       }
-      return handleResp();
+      if (executionContext.errors.length > 0) {
+        executionResult.errors = executionContext.errors;
+      }
+      return executionResult;
     }
   );
 }
@@ -465,41 +672,7 @@ function executeBatchFetchPlanNode(batchFetchNode, executionContext, batchContex
     batchContext,
     selectedVariables
   );
-  const handleBatchResult = (fetchResult) => {
-    if (utils.isAsyncIterable(fetchResult)) {
-      return promiseHelpers.mapAsyncIterator(fetchResult, handleBatchResult);
-    }
-    if (fetchResult.errors?.length) {
-      executionContext.errors.push(
-        ...normalizeBatchFetchErrors(fetchResult.errors, batchContext)
-      );
-    }
-    const responseData = fetchResult.data;
-    if (!responseData || typeof responseData !== "object") {
-      return;
-    }
-    for (const [aliasName, aliasContext] of batchContext.byAlias.entries()) {
-      let aliasData = responseData[aliasName];
-      if (!aliasData) {
-        continue;
-      }
-      if (aliasContext.outputRewrites?.length) {
-        aliasData = applyOutputRewrites(
-          aliasData,
-          aliasContext.outputRewrites,
-          executionContext.supergraphSchema
-        );
-      }
-      if (Array.isArray(aliasData)) {
-        applyBatchAliasEntities(
-          aliasData,
-          aliasContext
-        );
-      }
-    }
-    return;
-  };
-  return promiseHelpers.handleMaybePromise(
+  return handleMaybePromiseMaybeAsyncIterable(
     () => executionContext.onSubgraphExecute(batchFetchNode.serviceName, {
       document: getDocumentNodeOfFetchingNode(batchFetchNode),
       variables: variablesForFetch,
@@ -512,7 +685,42 @@ function executeBatchFetchPlanNode(batchFetchNode, executionContext, batchContex
       info: executionContext.executionRequest.info,
       signal: executionContext.executionRequest.signal
     }),
-    handleBatchResult
+    (fetchResult) => {
+      if (fetchResult.errors?.length) {
+        executionContext.errors.push(
+          ...normalizeBatchFetchErrors(fetchResult.errors, batchContext)
+        );
+      }
+      const responseData = fetchResult.data;
+      if (!responseData || typeof responseData !== "object") {
+        return;
+      }
+      for (const [aliasName, aliasContext] of batchContext.byAlias.entries()) {
+        let aliasData = responseData[aliasName];
+        if (!aliasData) {
+          continue;
+        }
+        if (aliasContext.outputRewrites?.length) {
+          aliasData = applyOutputRewrites(
+            aliasData,
+            aliasContext.outputRewrites,
+            executionContext.supergraphSchema
+          );
+        }
+        if (Array.isArray(aliasData)) {
+          applyBatchAliasEntities(
+            aliasData,
+            aliasContext
+          );
+        }
+      }
+      return;
+    },
+    (error) => handleSubgraphExecutionError(
+      error,
+      executionContext,
+      batchFetchNode.serviceName
+    )
   );
 }
 function executeFetchPlanNode(fetchNode, executionContext, state) {
@@ -582,53 +790,7 @@ function executeFetchPlanNode(fetchNode, executionContext, state) {
     variablesForFetch = variablesForFetch ? { ...selectedVariables, ...variablesForFetch } : { ...selectedVariables };
   }
   const defaultErrorPath = state?.errorPath ?? state?.flatten?.errorPath ?? getDefaultErrorPath(fetchNode);
-  const handleFetchResult = (fetchResult) => {
-    if (utils.isAsyncIterable(fetchResult)) {
-      return promiseHelpers.mapAsyncIterator(fetchResult, handleFetchResult);
-    }
-    if (fetchResult.errors?.length) {
-      const normalizedErrors = normalizeFetchErrors(fetchResult.errors, {
-        fetchNode,
-        state,
-        defaultPath: defaultErrorPath
-      });
-      if (normalizedErrors.length) {
-        executionContext.errors.push(...normalizedErrors);
-      }
-    }
-    const responseData = fetchNode.outputRewrites ? applyOutputRewrites(
-      fetchResult.data,
-      fetchNode.outputRewrites,
-      executionContext.supergraphSchema
-    ) : fetchResult.data;
-    if (!responseData) {
-      return;
-    }
-    if (flattenState && flattenState.entityRefs.length) {
-      const returnedEntities = responseData._entities;
-      if (Array.isArray(returnedEntities)) {
-        mergeFlattenEntities(returnedEntities, flattenState);
-      }
-      return;
-    }
-    if (representationTargets?.length && responseData._entities) {
-      const returnedEntities = responseData._entities;
-      for (let index = 0; index < returnedEntities.length; index++) {
-        const entity = returnedEntities[index];
-        const target = representationTargets[index];
-        if (target && entity) {
-          Object.assign(target, utils.mergeDeep([target, entity], false, true, true));
-        }
-      }
-      return;
-    }
-    Object.assign(
-      executionContext.data,
-      utils.mergeDeep([executionContext.data, responseData], false, true, true)
-    );
-    return;
-  };
-  return promiseHelpers.handleMaybePromise(
+  return handleMaybePromiseMaybeAsyncIterable(
     () => executionContext.onSubgraphExecute(fetchNode.serviceName, {
       document: getDocumentNodeOfFetchingNode(fetchNode),
       variables: variablesForFetch,
@@ -641,9 +803,76 @@ function executeFetchPlanNode(fetchNode, executionContext, state) {
       info: executionContext.executionRequest.info,
       signal: executionContext.executionRequest.signal
     }),
-    handleFetchResult
+    (fetchResult) => {
+      if (fetchResult.errors?.length) {
+        const normalizedErrors = normalizeFetchErrors(fetchResult.errors, {
+          fetchNode,
+          state,
+          defaultPath: defaultErrorPath
+        });
+        if (normalizedErrors.length) {
+          executionContext.errors.push(...normalizedErrors);
+        }
+      }
+      const responseData = fetchNode.outputRewrites ? applyOutputRewrites(
+        fetchResult.data,
+        fetchNode.outputRewrites,
+        executionContext.supergraphSchema
+      ) : fetchResult.data;
+      if (!responseData) {
+        return;
+      }
+      if (flattenState && flattenState.entityRefs.length) {
+        const returnedEntities = responseData._entities;
+        if (Array.isArray(returnedEntities)) {
+          mergeFlattenEntities(returnedEntities, flattenState);
+        }
+        return;
+      }
+      if (representationTargets?.length && responseData._entities) {
+        const returnedEntities = responseData._entities;
+        for (let index = 0; index < returnedEntities.length; index++) {
+          const entity = returnedEntities[index];
+          const target = representationTargets[index];
+          if (target && entity) {
+            Object.assign(
+              target,
+              utils.mergeDeep([target, entity], false, true, true)
+            );
+          }
+        }
+        return;
+      }
+      Object.assign(
+        executionContext.data,
+        utils.mergeDeep([executionContext.data, responseData], false, true, true)
+      );
+      return;
+    },
+    (error) => handleSubgraphExecutionError(
+      error,
+      executionContext,
+      fetchNode.serviceName,
+      defaultErrorPath
+    )
   );
 }
+function handleSubgraphExecutionError(error, executionContext, serviceName, path) {
+  let graphQLError;
+  if (error instanceof graphql.GraphQLError) {
+    graphQLError = error;
+  } else {
+    graphQLError = utils.createGraphQLError(error.message, {
+      originalError: error,
+      extensions: {
+        code: "DOWNSTREAM_SERVICE_ERROR",
+        serviceName
+      },
+      path
+    });
+  }
+  executionContext.errors.push(graphQLError);
+}
 function selectFetchVariables(variableValues, variableUsages) {
   if (!variableValues || !variableUsages || variableUsages.length === 0) {
     return void 0;
@@ -1333,20 +1562,12 @@ function projectRequires(requiresSelections, entity, supergraphSchema) {
   return result;
 }
 
-const queryPlanForExecutionRequestContext = /* @__PURE__ */ new WeakMap();
-function getLazyFactory(factory) {
-  let _value;
-  return function(...args) {
-    if (!_value) {
-      _value = factory();
-    }
-    return _value(...args);
-  };
-}
-
 async function unifiedGraphHandler(opts) {
   const getSubschema = getLazyFactory(
-    () => fusionRuntime.handleFederationSupergraph(opts).getSubschema
+    () => getHandledFederationSupergraph().getSubschema
+  );
+  const getHandledFederationSupergraph = getLazyValue(
+    () => fusionRuntime.handleFederationSupergraph(opts)
   );
   const moduleName = "@graphql-hive/router-query-planner";
   const { QueryPlanner } = await import(moduleName);
@@ -1440,45 +1661,96 @@ async function unifiedGraphHandler(opts) {
             supergraphSchema,
             executionRequest,
             onSubgraphExecute(subgraphName, executionRequest2) {
-              const subschema = getSubschema(subgraphName);
-              if (subschema.transforms?.length) {
-                const transforms = subschema.transforms;
-                const transformationContext = /* @__PURE__ */ Object.create(null);
-                for (const transform of transforms) {
-                  if (transform.transformRequest) {
-                    executionRequest2 = transform.transformRequest(
-                      executionRequest2,
-                      void 0,
-                      transformationContext
-                    );
-                  }
-                }
-                return promiseHelpers.handleMaybePromise(
-                  () => opts.onSubgraphExecute(subgraphName, executionRequest2),
+              function executeSubgraph(executionRequest3) {
+                return handleMaybePromiseMaybeAsyncIterable(
+                  () => onSubgraphExecuteWithTransforms(
+                    subgraphName,
+                    executionRequest3,
+                    opts.onSubgraphExecute,
+                    getSubschema
+                  ),
                   (executionResult) => {
-                    function handleResult(executionResult2) {
-                      for (const transform of transforms.toReversed()) {
-                        if (transform.transformResult) {
-                          executionResult2 = transform.transformResult(
-                            executionResult2,
-                            void 0,
-                            transformationContext
-                          );
-                        }
-                      }
-                      return executionResult2;
-                    }
-                    if (utils.isAsyncIterable(executionResult)) {
-                      return promiseHelpers.mapAsyncIterator(
-                        executionResult,
-                        (result) => handleResult(result)
+                    if (executionRequest3.operationType === "mutation") {
+                      handleResultWithPubSubPublish(
+                        supergraphSchema,
+                        executionRequest3,
+                        executionResult
                       );
                     }
-                    return handleResult(executionResult);
+                    return executionResult;
                   }
                 );
               }
-              return opts.onSubgraphExecute(subgraphName, executionRequest2);
+              const maybeResult = handlePubsubOperationField(
+                supergraphSchema,
+                executionRequest2
+              );
+              if (maybeResult) {
+                const {
+                  executionResult,
+                  newExecutionRequest,
+                  responseKey,
+                  returnTypeName
+                } = maybeResult;
+                if (newExecutionRequest) {
+                  return promiseHelpers.mapAsyncIterator(
+                    executionResult,
+                    (executionResult2) => {
+                      if (executionResult2.data?.[responseKey] != null) {
+                        const representations = utils.asArray(
+                          executionResult2.data[responseKey]
+                        );
+                        if (returnTypeName) {
+                          for (const representation of representations) {
+                            representation.__typename = returnTypeName;
+                          }
+                        }
+                        return handleMaybePromiseMaybeAsyncIterable(
+                          () => executeSubgraph({
+                            ...newExecutionRequest,
+                            variables: {
+                              representations
+                            }
+                          }),
+                          (entitiesResult) => {
+                            if (entitiesResult?.data?._entities?.length) {
+                              const entities = utils.asArray(
+                                entitiesResult.data._entities
+                              );
+                              for (let i = 0; i < entities.length; i++) {
+                                const entity = entities[i];
+                                const representation = representations[i];
+                                if (entity != null && representation != null) {
+                                  Object.assign(
+                                    representation,
+                                    utils.mergeDeep(
+                                      [entity, representation],
+                                      false,
+                                      true,
+                                      true
+                                    )
+                                  );
+                                }
+                              }
+                              return executionResult2;
+                            }
+                            if (entitiesResult?.errors?.length) {
+                              executionResult2.errors ||= [];
+                              executionResult2.errors.push(
+                                ...entitiesResult.errors
+                              );
+                            }
+                            return executionResult2;
+                          }
+                        );
+                      }
+                      return executionResult2;
+                    }
+                  );
+                }
+                return executionResult;
+              }
+              return executeSubgraph(executionRequest2);
             },
             queryPlan
           });

package/dist/index.js

@@ -2,12 +2,225 @@ import { handleFederationSupergraph } from '@graphql-mesh/fusion-runtime';
 import { createDefaultExecutor } from '@graphql-mesh/transport-common';
 import { defaultPrintFn } from '@graphql-tools/executor-common';
 import { filterInternalFieldsAndTypes, getRngFromEnv } from '@graphql-tools/federation';
-import { isAsyncIterable, getOperationASTFromRequest, mergeDeep, memoize1, getOperationASTFromDocument, relocatedError, getDirective } from '@graphql-tools/utils';
-import { handleMaybePromise, mapAsyncIterator, isPromise } from '@whatwg-node/promise-helpers';
-import { parse, isObjectType, isAbstractType, Kind, isInterfaceType, TypeNameMetaFieldDef, getNamedType, isEnumType, isNonNullType, isOutputType, visit, BREAK } from 'graphql';
+import { memoize1, memoize2, createGraphQLError, visitResult, getDirectiveInExtensions, mapAsyncIterator, isAsyncIterable, getOperationASTFromRequest, getOperationASTFromDocument, mergeDeep, relocatedError, getDirective, asArray } from '@graphql-tools/utils';
+import { handleMaybePromise, mapAsyncIterator as mapAsyncIterator$1, isPromise } from '@whatwg-node/promise-helpers';
+import { TypeInfo, versionInfo, visit, visitWithTypeInfo, getNamedType, BREAK, parse, print, Kind, isObjectType, isInterfaceType, TypeNameMetaFieldDef, isEnumType, isNonNullType, isOutputType, GraphQLError, isAbstractType } from 'graphql';
 import { documentStringMap } from '@envelop/core';
 import { getFragmentsFromDocument, getVariableValues } from '@graphql-tools/executor';
 
+const getTypeInfo = memoize1(function getTypeInfo2(schema) {
+  return new TypeInfo(schema);
+});
+memoize2(function getTypeInfoWithType2(schema, type) {
+  return versionInfo.major < 16 ? new TypeInfo(schema, void 0, type) : new TypeInfo(schema, type);
+});
+
+const getPubsubOperationRootFields = memoize1(function(schema) {
+  const pubsubOperationFields = /* @__PURE__ */ new Map();
+  const subscriptionType = schema.getSubscriptionType();
+  if (subscriptionType) {
+    const subscriptionFields = subscriptionType.getFields();
+    for (const fieldName in subscriptionFields) {
+      const fieldDef = subscriptionFields[fieldName];
+      if (fieldDef) {
+        const pubsubOperations = getDirectiveInExtensions(
+          fieldDef,
+          "pubsubOperation"
+        );
+        if (pubsubOperations) {
+          for (const { pubsubTopic } of pubsubOperations) {
+            pubsubOperationFields.set(fieldDef.name, pubsubTopic);
+          }
+        }
+      }
+    }
+  }
+  return pubsubOperationFields;
+});
+function resolvePubsubOperationRootField(responseKey, topicName, pubsub) {
+  return mapAsyncIterator(pubsub.subscribe(topicName), (payload) => ({
+    data: {
+      [responseKey]: payload
+    }
+  }));
+}
+function handlePubsubOperationField(supergraphSchema, executionRequest) {
+  if (executionRequest.operationType === "subscription") {
+    const typeInfo = getTypeInfo(supergraphSchema);
+    let responseKey;
+    let fieldName;
+    let selectionSet;
+    let returnType;
+    visit(
+      executionRequest.document,
+      visitWithTypeInfo(typeInfo, {
+        Field(node) {
+          const parentType = typeInfo.getParentType();
+          if (parentType === supergraphSchema.getSubscriptionType()) {
+            responseKey = node.alias?.value || node.name.value;
+            fieldName = node.name.value;
+            selectionSet = node.selectionSet;
+            const fieldDef = typeInfo.getFieldDef();
+            if (fieldDef) {
+              returnType = getNamedType(fieldDef.type);
+            }
+            return BREAK;
+          }
+          return node;
+        }
+      })
+    );
+    if (responseKey && fieldName) {
+      const pubsubOperationFields = getPubsubOperationRootFields(supergraphSchema);
+      const pubsubTopic = pubsubOperationFields.get(fieldName);
+      if (pubsubTopic) {
+        const pubsub = executionRequest.context?.pubsub;
+        if (!pubsub) {
+          throw createGraphQLError(
+            `You have to configure a PubSub instance in the context to execute subscription operations with @pubsubOperation directive.`
+          );
+        }
+        let newExecutionRequest;
+        if (selectionSet && returnType) {
+          const newDocument = parse(
+            /* GraphQL */
+            `
+                query ${executionRequest.operationName}($representations: [_Any!]!) {
+                    _entities(representations: $representations) {
+                        __typename
+                        ... on ${returnType.name} ${print(selectionSet)}
+                    }
+                } 
+            `
+          );
+          newExecutionRequest = {
+            ...executionRequest,
+            document: newDocument
+          };
+        }
+        return {
+          executionResult: resolvePubsubOperationRootField(
+            responseKey,
+            pubsubTopic,
+            pubsub
+          ),
+          responseKey,
+          returnTypeName: returnType?.name,
+          newExecutionRequest
+        };
+      }
+    }
+  }
+  return false;
+}
+const getPubsubPublishVisitor = memoize2(function getPubsubPublishFields(schema, pubsub) {
+  const pubsubPublishVisitor = {};
+  for (const typeName in schema.getTypeMap()) {
+    const type = schema.getType(typeName);
+    if (type != null && "getFields" in type) {
+      const fields = type.getFields();
+      for (const fieldName in fields) {
+        const fieldDef = fields[fieldName];
+        if (fieldDef) {
+          const pubsubPublishes = getDirectiveInExtensions(
+            fieldDef,
+            "pubsubPublish"
+          );
+          if (pubsubPublishes) {
+            for (const { pubsubTopic } of pubsubPublishes) {
+              const typeVisitor = pubsubPublishVisitor[typeName] ||= {};
+              typeVisitor[fieldName] = (value) => {
+                pubsub.publish(pubsubTopic, value);
+                return value;
+              };
+            }
+          }
+        }
+      }
+    }
+  }
+  if (!Object.keys(pubsubPublishVisitor).length) {
+    return false;
+  }
+  return pubsubPublishVisitor;
+});
+function handleResultWithPubSubPublish(schema, request, result) {
+  if (result.data != null && request.context?.pubsub != null) {
+    const pubsubPublishVisitor = getPubsubPublishVisitor(
+      schema,
+      request.context.pubsub
+    );
+    if (pubsubPublishVisitor) {
+      return visitResult(result, request, schema, pubsubPublishVisitor);
+    }
+  }
+}
+
+const queryPlanForExecutionRequestContext = /* @__PURE__ */ new WeakMap();
+function getLazyValue(factory) {
+  let _value;
+  return function() {
+    if (_value == null) {
+      _value = factory();
+    }
+    return _value;
+  };
+}
+function getLazyFactory(factory) {
+  let _value;
+  return function(...args) {
+    if (!_value) {
+      _value = factory();
+    }
+    return _value(...args);
+  };
+}
+function onSubgraphExecuteWithTransforms(subgraphName, executionRequest, onSubgraphExecute, getSubschema) {
+  const subschema = getSubschema(subgraphName);
+  if (subschema.transforms?.length) {
+    const transforms = subschema.transforms;
+    const transformationContext = /* @__PURE__ */ Object.create(null);
+    const delegationContext = void 0;
+    for (const transform of transforms) {
+      if (transform.transformRequest) {
+        executionRequest = transform.transformRequest(
+          executionRequest,
+          delegationContext,
+          transformationContext
+        );
+      }
+    }
+    return handleMaybePromiseMaybeAsyncIterable(
+      () => onSubgraphExecute(subgraphName, executionRequest),
+      (executionResult) => {
+        for (const transform of transforms.toReversed()) {
+          if (transform.transformResult) {
+            executionResult = transform.transformResult(
+              executionResult,
+              delegationContext,
+              transformationContext
+            );
+          }
+        }
+        return executionResult;
+      }
+    );
+  }
+  return onSubgraphExecute(subgraphName, executionRequest);
+}
+function handleMaybePromiseMaybeAsyncIterable(executor, mapper, errorMapper) {
+  return handleMaybePromise(
+    executor,
+    (result$) => {
+      if (isAsyncIterable(result$)) {
+        return mapAsyncIterator$1(result$, mapper, errorMapper);
+      }
+      return mapper(result$);
+    },
+    errorMapper
+  );
+}
+
 function isEntityRepresentation(obj) {
   return obj?.__typename != null;
 }
@@ -26,23 +239,17 @@ function executeQueryPlan({
     executionRequest,
     onSubgraphExecute
   });
-  function handleResp() {
-    const executionResult = {};
-    if (Object.keys(executionContext.data).length > 0) {
-      executionResult.data = projectDataByOperation(executionContext);
-    }
-    if (executionContext.errors.length > 0) {
-      executionResult.errors = executionContext.errors;
-    }
-    return executionResult;
-  }
-  return handleMaybePromise(
+  return handleMaybePromiseMaybeAsyncIterable(
     () => executePlanNode(node, executionContext),
-    (res) => {
-      if (isAsyncIterable(res)) {
-        return mapAsyncIterator(res, handleResp);
+    () => {
+      const executionResult = {};
+      if (Object.keys(executionContext.data).length > 0) {
+        executionResult.data = projectDataByOperation(executionContext);
       }
-      return handleResp();
+      if (executionContext.errors.length > 0) {
+        executionResult.errors = executionContext.errors;
+      }
+      return executionResult;
     }
   );
 }
@@ -463,41 +670,7 @@ function executeBatchFetchPlanNode(batchFetchNode, executionContext, batchContex
     batchContext,
     selectedVariables
   );
-  const handleBatchResult = (fetchResult) => {
-    if (isAsyncIterable(fetchResult)) {
-      return mapAsyncIterator(fetchResult, handleBatchResult);
-    }
-    if (fetchResult.errors?.length) {
-      executionContext.errors.push(
-        ...normalizeBatchFetchErrors(fetchResult.errors, batchContext)
-      );
-    }
-    const responseData = fetchResult.data;
-    if (!responseData || typeof responseData !== "object") {
-      return;
-    }
-    for (const [aliasName, aliasContext] of batchContext.byAlias.entries()) {
-      let aliasData = responseData[aliasName];
-      if (!aliasData) {
-        continue;
-      }
-      if (aliasContext.outputRewrites?.length) {
-        aliasData = applyOutputRewrites(
-          aliasData,
-          aliasContext.outputRewrites,
-          executionContext.supergraphSchema
-        );
-      }
-      if (Array.isArray(aliasData)) {
-        applyBatchAliasEntities(
-          aliasData,
-          aliasContext
-        );
-      }
-    }
-    return;
-  };
-  return handleMaybePromise(
+  return handleMaybePromiseMaybeAsyncIterable(
     () => executionContext.onSubgraphExecute(batchFetchNode.serviceName, {
       document: getDocumentNodeOfFetchingNode(batchFetchNode),
       variables: variablesForFetch,
@@ -510,7 +683,42 @@ function executeBatchFetchPlanNode(batchFetchNode, executionContext, batchContex
       info: executionContext.executionRequest.info,
       signal: executionContext.executionRequest.signal
     }),
-    handleBatchResult
+    (fetchResult) => {
+      if (fetchResult.errors?.length) {
+        executionContext.errors.push(
+          ...normalizeBatchFetchErrors(fetchResult.errors, batchContext)
+        );
+      }
+      const responseData = fetchResult.data;
+      if (!responseData || typeof responseData !== "object") {
+        return;
+      }
+      for (const [aliasName, aliasContext] of batchContext.byAlias.entries()) {
+        let aliasData = responseData[aliasName];
+        if (!aliasData) {
+          continue;
+        }
+        if (aliasContext.outputRewrites?.length) {
+          aliasData = applyOutputRewrites(
+            aliasData,
+            aliasContext.outputRewrites,
+            executionContext.supergraphSchema
+          );
+        }
+        if (Array.isArray(aliasData)) {
+          applyBatchAliasEntities(
+            aliasData,
+            aliasContext
+          );
+        }
+      }
+      return;
+    },
+    (error) => handleSubgraphExecutionError(
+      error,
+      executionContext,
+      batchFetchNode.serviceName
+    )
   );
 }
 function executeFetchPlanNode(fetchNode, executionContext, state) {
@@ -580,53 +788,7 @@ function executeFetchPlanNode(fetchNode, executionContext, state) {
     variablesForFetch = variablesForFetch ? { ...selectedVariables, ...variablesForFetch } : { ...selectedVariables };
   }
   const defaultErrorPath = state?.errorPath ?? state?.flatten?.errorPath ?? getDefaultErrorPath(fetchNode);
-  const handleFetchResult = (fetchResult) => {
-    if (isAsyncIterable(fetchResult)) {
-      return mapAsyncIterator(fetchResult, handleFetchResult);
-    }
-    if (fetchResult.errors?.length) {
-      const normalizedErrors = normalizeFetchErrors(fetchResult.errors, {
-        fetchNode,
-        state,
-        defaultPath: defaultErrorPath
-      });
-      if (normalizedErrors.length) {
-        executionContext.errors.push(...normalizedErrors);
-      }
-    }
-    const responseData = fetchNode.outputRewrites ? applyOutputRewrites(
-      fetchResult.data,
-      fetchNode.outputRewrites,
-      executionContext.supergraphSchema
-    ) : fetchResult.data;
-    if (!responseData) {
-      return;
-    }
-    if (flattenState && flattenState.entityRefs.length) {
-      const returnedEntities = responseData._entities;
-      if (Array.isArray(returnedEntities)) {
-        mergeFlattenEntities(returnedEntities, flattenState);
-      }
-      return;
-    }
-    if (representationTargets?.length && responseData._entities) {
-      const returnedEntities = responseData._entities;
-      for (let index = 0; index < returnedEntities.length; index++) {
-        const entity = returnedEntities[index];
-        const target = representationTargets[index];
-        if (target && entity) {
-          Object.assign(target, mergeDeep([target, entity], false, true, true));
-        }
-      }
-      return;
-    }
-    Object.assign(
-      executionContext.data,
-      mergeDeep([executionContext.data, responseData], false, true, true)
-    );
-    return;
-  };
-  return handleMaybePromise(
+  return handleMaybePromiseMaybeAsyncIterable(
     () => executionContext.onSubgraphExecute(fetchNode.serviceName, {
       document: getDocumentNodeOfFetchingNode(fetchNode),
       variables: variablesForFetch,
@@ -639,9 +801,76 @@ function executeFetchPlanNode(fetchNode, executionContext, state) {
       info: executionContext.executionRequest.info,
       signal: executionContext.executionRequest.signal
     }),
-    handleFetchResult
+    (fetchResult) => {
+      if (fetchResult.errors?.length) {
+        const normalizedErrors = normalizeFetchErrors(fetchResult.errors, {
+          fetchNode,
+          state,
+          defaultPath: defaultErrorPath
+        });
+        if (normalizedErrors.length) {
+          executionContext.errors.push(...normalizedErrors);
+        }
+      }
+      const responseData = fetchNode.outputRewrites ? applyOutputRewrites(
+        fetchResult.data,
+        fetchNode.outputRewrites,
+        executionContext.supergraphSchema
+      ) : fetchResult.data;
+      if (!responseData) {
+        return;
+      }
+      if (flattenState && flattenState.entityRefs.length) {
+        const returnedEntities = responseData._entities;
+        if (Array.isArray(returnedEntities)) {
+          mergeFlattenEntities(returnedEntities, flattenState);
+        }
+        return;
+      }
+      if (representationTargets?.length && responseData._entities) {
+        const returnedEntities = responseData._entities;
+        for (let index = 0; index < returnedEntities.length; index++) {
+          const entity = returnedEntities[index];
+          const target = representationTargets[index];
+          if (target && entity) {
+            Object.assign(
+              target,
+              mergeDeep([target, entity], false, true, true)
+            );
+          }
+        }
+        return;
+      }
+      Object.assign(
+        executionContext.data,
+        mergeDeep([executionContext.data, responseData], false, true, true)
+      );
+      return;
+    },
+    (error) => handleSubgraphExecutionError(
+      error,
+      executionContext,
+      fetchNode.serviceName,
+      defaultErrorPath
+    )
   );
 }
+function handleSubgraphExecutionError(error, executionContext, serviceName, path) {
+  let graphQLError;
+  if (error instanceof GraphQLError) {
+    graphQLError = error;
+  } else {
+    graphQLError = createGraphQLError(error.message, {
+      originalError: error,
+      extensions: {
+        code: "DOWNSTREAM_SERVICE_ERROR",
+        serviceName
+      },
+      path
+    });
+  }
+  executionContext.errors.push(graphQLError);
+}
 function selectFetchVariables(variableValues, variableUsages) {
   if (!variableValues || !variableUsages || variableUsages.length === 0) {
     return void 0;
@@ -1331,20 +1560,12 @@ function projectRequires(requiresSelections, entity, supergraphSchema) {
   return result;
 }
 
-const queryPlanForExecutionRequestContext = /* @__PURE__ */ new WeakMap();
-function getLazyFactory(factory) {
-  let _value;
-  return function(...args) {
-    if (!_value) {
-      _value = factory();
-    }
-    return _value(...args);
-  };
-}
-
 async function unifiedGraphHandler(opts) {
   const getSubschema = getLazyFactory(
-    () => handleFederationSupergraph(opts).getSubschema
+    () => getHandledFederationSupergraph().getSubschema
+  );
+  const getHandledFederationSupergraph = getLazyValue(
+    () => handleFederationSupergraph(opts)
   );
   const moduleName = "@graphql-hive/router-query-planner";
   const { QueryPlanner } = await import(moduleName);
@@ -1438,45 +1659,96 @@ async function unifiedGraphHandler(opts) {
             supergraphSchema,
             executionRequest,
             onSubgraphExecute(subgraphName, executionRequest2) {
-              const subschema = getSubschema(subgraphName);
-              if (subschema.transforms?.length) {
-                const transforms = subschema.transforms;
-                const transformationContext = /* @__PURE__ */ Object.create(null);
-                for (const transform of transforms) {
-                  if (transform.transformRequest) {
-                    executionRequest2 = transform.transformRequest(
-                      executionRequest2,
-                      void 0,
-                      transformationContext
-                    );
-                  }
-                }
-                return handleMaybePromise(
-                  () => opts.onSubgraphExecute(subgraphName, executionRequest2),
+              function executeSubgraph(executionRequest3) {
+                return handleMaybePromiseMaybeAsyncIterable(
+                  () => onSubgraphExecuteWithTransforms(
+                    subgraphName,
+                    executionRequest3,
+                    opts.onSubgraphExecute,
+                    getSubschema
+                  ),
                   (executionResult) => {
-                    function handleResult(executionResult2) {
-                      for (const transform of transforms.toReversed()) {
-                        if (transform.transformResult) {
-                          executionResult2 = transform.transformResult(
-                            executionResult2,
-                            void 0,
-                            transformationContext
-                          );
-                        }
-                      }
-                      return executionResult2;
-                    }
-                    if (isAsyncIterable(executionResult)) {
-                      return mapAsyncIterator(
-                        executionResult,
-                        (result) => handleResult(result)
+                    if (executionRequest3.operationType === "mutation") {
+                      handleResultWithPubSubPublish(
+                        supergraphSchema,
+                        executionRequest3,
+                        executionResult
                       );
                     }
-                    return handleResult(executionResult);
+                    return executionResult;
                   }
                 );
               }
-              return opts.onSubgraphExecute(subgraphName, executionRequest2);
+              const maybeResult = handlePubsubOperationField(
+                supergraphSchema,
+                executionRequest2
+              );
+              if (maybeResult) {
+                const {
+                  executionResult,
+                  newExecutionRequest,
+                  responseKey,
+                  returnTypeName
+                } = maybeResult;
+                if (newExecutionRequest) {
+                  return mapAsyncIterator$1(
+                    executionResult,
+                    (executionResult2) => {
+                      if (executionResult2.data?.[responseKey] != null) {
+                        const representations = asArray(
+                          executionResult2.data[responseKey]
+                        );
+                        if (returnTypeName) {
+                          for (const representation of representations) {
+                            representation.__typename = returnTypeName;
+                          }
+                        }
+                        return handleMaybePromiseMaybeAsyncIterable(
+                          () => executeSubgraph({
+                            ...newExecutionRequest,
+                            variables: {
+                              representations
+                            }
+                          }),
+                          (entitiesResult) => {
+                            if (entitiesResult?.data?._entities?.length) {
+                              const entities = asArray(
+                                entitiesResult.data._entities
+                              );
+                              for (let i = 0; i < entities.length; i++) {
+                                const entity = entities[i];
+                                const representation = representations[i];
+                                if (entity != null && representation != null) {
+                                  Object.assign(
+                                    representation,
+                                    mergeDeep(
+                                      [entity, representation],
+                                      false,
+                                      true,
+                                      true
+                                    )
+                                  );
+                                }
+                              }
+                              return executionResult2;
+                            }
+                            if (entitiesResult?.errors?.length) {
+                              executionResult2.errors ||= [];
+                              executionResult2.errors.push(
+                                ...entitiesResult.errors
+                              );
+                            }
+                            return executionResult2;
+                          }
+                        );
+                      }
+                      return executionResult2;
+                    }
+                  );
+                }
+                return executionResult;
+              }
+              return executeSubgraph(executionRequest2);
             },
             queryPlan
           });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphql-hive/router-runtime",
-  "version": "1.2.5",
+  "version": "1.3.0-alpha-a990d4c23ad5a2cd3bc5526ee8a987fa39a5ca86",
   "type": "module",
   "repository": {
     "type": "git",