on perform plugin

Author: enisdenjo

packages/core/src/orchestrator.ts

@@ -31,6 +31,9 @@ import {
   ValidateFunction,
   ExecutionResult,
   PerformFunction,
+  OnPerformHook,
+  OnPerformHookResult,
+  OnPerformDoneHook,
 } from '@envelop/types';
 import {
   errorAsyncIterator,
@@ -118,15 +121,17 @@ export function createEnvelopOrchestrator<PluginsContext extends DefaultContext>
     subscribe: [] as OnSubscribeHook<any>[],
     execute: [] as OnExecuteHook<any>[],
     context: [] as OnContextBuildingHook<any>[],
+    perform: [] as OnPerformHook<any>[],
   };
 
-  for (const { onContextBuilding, onExecute, onParse, onSubscribe, onValidate, onEnveloped } of plugins) {
+  for (const { onContextBuilding, onExecute, onParse, onSubscribe, onValidate, onEnveloped, onPerform } of plugins) {
     onEnveloped && beforeCallbacks.init.push(onEnveloped);
     onContextBuilding && beforeCallbacks.context.push(onContextBuilding);
     onExecute && beforeCallbacks.execute.push(onExecute);
     onParse && beforeCallbacks.parse.push(onParse);
     onSubscribe && beforeCallbacks.subscribe.push(onSubscribe);
     onValidate && beforeCallbacks.validate.push(onValidate);
+    onPerform && beforeCallbacks.perform.push(onPerform);
   }
 
   const init: EnvelopOrchestrator['init'] = initialContext => {
@@ -565,6 +570,24 @@ export function createEnvelopOrchestrator<PluginsContext extends DefaultContext>
     const contextFactory = customContextFactory(initialContext);
 
     return async (params, contextExtension) => {
+      const context = await contextFactory(contextExtension);
+
+      const doneFns: OnPerformDoneHook[] = [];
+      for (const onPerform of beforeCallbacks.perform) {
+        const result = await onPerform({
+          context,
+          extendContext: extension => {
+            Object.assign(context, extension);
+          },
+          params,
+          setParams: newParams => {
+            params = newParams;
+          },
+        });
+
+        result?.onPerformDone && doneFns.push(result.onPerformDone);
+      }
+
       let document;
       try {
         document = parse(params.query);
@@ -577,23 +600,33 @@ export function createEnvelopOrchestrator<PluginsContext extends DefaultContext>
         return { errors: validationErrors };
       }
 
-      const context = await contextFactory(contextExtension);
-
+      let result;
       if (isSubscriptionOperation(document, params.operationName)) {
-        return await customSubscribe({
+        result = await customSubscribe({
+          document,
+          schema,
+          variableValues: params.variables,
+          contextValue: context,
+        });
+      } else {
+        result = await customExecute({
           document,
           schema,
           variableValues: params.variables,
           contextValue: context,
         });
       }
 
-      return await customExecute({
-        document,
-        schema,
-        variableValues: params.variables,
-        contextValue: context,
-      });
+      for (const doneFn of doneFns) {
+        doneFn({
+          result,
+          setResult: newResult => {
+            result = newResult;
+          },
+        });
+      }
+
+      return result;
     };
   };
 

packages/core/test/perform.spec.ts

@@ -1,5 +1,5 @@
 import { parse, validate, execute, subscribe } from 'graphql';
-import { envelop, useSchema } from '../src/index.js';
+import { envelop, OnPerformDoneHook, OnPerformHook, useSchema } from '../src/index.js';
 import { assertSingleExecutionValue, assertStreamExecutionValue } from '@envelop/testing';
 import { makeExecutableSchema } from '@graphql-tools/schema';
 
@@ -103,4 +103,40 @@ describe('perform', () => {
       }
     `);
   });
+
+  it('should invoke onPerform plugin hooks', async () => {
+    const onPerformDoneFn = jest.fn((() => {
+      // noop
+    }) as OnPerformDoneHook);
+    const onPerformFn = jest.fn((() => ({
+      onPerformDone: onPerformDoneFn,
+    })) as OnPerformHook<any>);
+
+    const getEnveloped = envelop({
+      ...graphqlFuncs,
+      plugins: [
+        useSchema(schema),
+        {
+          onPerform: onPerformFn,
+        },
+      ],
+    });
+
+    const params = { query: '{ hello }' };
+    const { perform } = getEnveloped({ initial: 'context' });
+    await perform(params, { extension: 'context' });
+
+    expect(onPerformFn).toBeCalled();
+    expect(onPerformFn.mock.calls[0][0].context).toEqual({ initial: 'context', extension: 'context' });
+    expect(onPerformFn.mock.calls[0][0].params).toBe(params);
+
+    expect(onPerformDoneFn).toBeCalled();
+    expect(onPerformDoneFn.mock.calls[0][0].result).toMatchInlineSnapshot(`
+      Object {
+        "data": Object {
+          "hello": "world",
+        },
+      }
+    `);
+  });
 });

packages/types/src/hooks.ts

@@ -519,7 +519,9 @@ export type PerformFunction<ContextExtension = unknown> = (
   contextExtension?: ContextExtension
 ) => Promise<AsyncIterableIteratorOrValue<ExecutionResult>>;
 
-export type OnPerformEventPayload = {
+export type OnPerformEventPayload<ContextType> = {
+  context: Readonly<ContextType>;
+  extendContext: (contextExtension: Partial<ContextType>) => void;
   params: PerformParams;
   setParams: (newParams: PerformParams) => void;
 };
@@ -535,4 +537,6 @@ export type OnPerformHookResult = {
   onPerformDone?: OnPerformDoneHook;
 };
 
-export type OnPerformHook = (options: OnPerformEventPayload) => PromiseOrValue<void | OnPerformHookResult>;
+export type OnPerformHook<ContextType> = (
+  options: OnPerformEventPayload<ContextType>
+) => PromiseOrValue<void | OnPerformHookResult>;

packages/types/src/plugin.ts

@@ -46,5 +46,5 @@ export interface Plugin<PluginContext extends Record<string, any> = {}> {
   /**
    * Invoked for each perform call.
    */
-  onPerform?: OnPerformHook;
+  onPerform?: OnPerformHook<PluginContext>;
 }