Convert remaining plugins from apollo to yoga

Author: CarsonF

src/components/authentication/current-user.provider.ts

@@ -1,4 +1,3 @@
-import { Plugin } from '@nestjs/apollo';
 import {
   CallHandler,
   ExecutionContext,
@@ -13,7 +12,6 @@ import { EdgeDB, OptionsFn } from '~/core/edgedb';
 import { HttpMiddleware } from '~/core/http';
 
 @Injectable()
-@Plugin()
 export class EdgeDBCurrentUserProvider
   implements HttpMiddleware, NestInterceptor
 {

src/core/graphql/graphql-logging.plugin.ts

@@ -1,34 +1,38 @@
 import {
-  ApolloServerPlugin as ApolloPlugin,
-  GraphQLRequestContext as RequestContext,
-  GraphQLRequestListener as RequestListener,
-} from '@apollo/server';
-import { Plugin } from '@nestjs/apollo';
+  OnExecuteEventPayload as OnExecute,
+  OnSubscribeEventPayload as OnSubscribe,
+} from '@envelop/types';
+import { Injectable } from '@nestjs/common';
 import { GqlContextType as ContextType } from '~/common';
 import { maskSecrets } from '~/common/mask-secrets';
 import { ILogger, Logger } from '../logger';
+import { Plugin } from './plugin.decorator';
 
 /**
  * Logging for GraphQL errors that are not handled anywhere else
  * Note: Lots of assumptions here.
  */
 @Plugin()
-export class GraphqlLoggingPlugin implements ApolloPlugin<ContextType> {
+@Injectable()
+export class GraphqlLoggingPlugin {
   constructor(@Logger('graphql') private readonly logger: ILogger) {}
 
-  async requestDidStart(
-    _context: RequestContext<ContextType>,
-  ): Promise<RequestListener<ContextType>> {
-    return {
-      executionDidStart: async ({ operationName, operation, request }) => {
-        if (operationName === 'IntrospectionQuery') {
-          return;
-        }
-        this.logger.info(`Received ${operation.operation}`, {
-          operation: operationName,
-          ...maskSecrets(request.variables ?? {}),
-        });
-      },
-    };
+  onExecute: Plugin['onExecute'] = ({ args }) => {
+    this.logReq(args);
+  };
+
+  onSubscribe: Plugin['onSubscribe'] = ({ args }) => {
+    this.logReq(args);
+  };
+
+  logReq(args: (OnExecute<ContextType> | OnSubscribe<ContextType>)['args']) {
+    const { operationName, variableValues, contextValue } = args;
+    if (operationName === 'IntrospectionQuery') {
+      return;
+    }
+    this.logger.info(`Received ${contextValue.operation.operation}`, {
+      operation: operationName,
+      ...maskSecrets(variableValues ?? {}),
+    });
   }
 }

src/core/graphql/graphql-session.plugin.ts

@@ -1,23 +1,12 @@
-import {
-  ApolloServerPlugin as ApolloPlugin,
-  GraphQLRequestContext as RequestContext,
-  GraphQLRequestListener as RequestListener,
-  GraphQLRequestContextWillSendResponse as WillSendResponse,
-} from '@apollo/server';
-import { Plugin } from '@nestjs/apollo';
-import { GqlContextType as ContextType } from '~/common';
+import { Plugin } from './plugin.decorator';
 
 @Plugin()
-export class GraphqlSessionPlugin implements ApolloPlugin<ContextType> {
-  async requestDidStart(
-    _context: RequestContext<ContextType>,
-  ): Promise<RequestListener<ContextType>> {
-    return {
-      async willSendResponse(context: WillSendResponse<ContextType>) {
-        // I suspect this is important to ensure that subscriptions
-        // will close without burdening the subscribers to do so.
-        context.contextValue.session$.complete();
-      },
-    };
-  }
+export class GraphqlSessionPlugin {
+  onExecute: Plugin['onExecute'] = ({ args }) => ({
+    onExecuteDone: () => {
+      // I suspect this is important to ensure that subscriptions
+      // will close without burdening the subscribers to do so.
+      args.contextValue.session$.complete();
+    },
+  });
 }

src/core/graphql/graphql-tracing.plugin.ts

@@ -1,60 +1,60 @@
-import {
-  ApolloServerPlugin as ApolloPlugin,
-  GraphQLRequestExecutionListener as ExecutionListener,
-  GraphQLRequestListener as Listener,
-} from '@apollo/server';
-import { Plugin } from '@nestjs/apollo';
 import { FieldMiddleware } from '@nestjs/graphql';
+import { createHash } from 'crypto';
 import { GraphQLResolveInfo as ResolveInfo, ResponsePath } from 'graphql';
-import { GqlContextType as ContextType } from '~/common';
 import { Segment, TracingService } from '../tracing';
+import { Plugin } from './plugin.decorator';
 
 @Plugin()
-export class GraphqlTracingPlugin implements ApolloPlugin<ContextType> {
+export class GraphqlTracingPlugin {
   constructor(private readonly tracing: TracingService) {}
 
-  async requestDidStart(): Promise<Listener<ContextType>> {
-    return {
-      executionDidStart: async (
-        reqContext,
-      ): Promise<ExecutionListener<ContextType>> => {
-        let segment: Segment;
-        try {
-          segment = this.tracing.rootSegment;
-        } catch (e) {
-          return {};
-        }
+  onExecute: Plugin['onExecute'] = ({ args }) => {
+    const { operationName, contextValue } = args;
+    const { operation, session$, params } = contextValue;
+
+    let segment: Segment;
+    try {
+      segment = this.tracing.rootSegment;
+    } catch (e) {
+      return {};
+    }
+
+    segment.name =
+      operationName ??
+      (params.query
+        ? createHash('sha256').update(params.query).digest('hex')
+        : undefined);
+    segment.addAnnotation(operation.operation, true);
 
-        segment.name = reqContext.operationName ?? reqContext.queryHash;
-        segment.addAnnotation(reqContext.operation.operation, true);
+    // Append operation name to url since all gql requests hit a single http endpoint
+    if (
+      // Check if http middleware is present, confirming this is a root subsegment
+      (segment as any).http?.request &&
+      // Confirm operation caller didn't do it themselves.
+      // They should, but it's not currently required.
+      !(segment as any).http.request.url.endsWith(segment.name)
+    ) {
+      // @ts-expect-error xray library types suck
+      (segment.http.request.url as string) += '/' + segment.name;
+    }
 
-        // Append operation name to url since all gql requests hit a single http endpoint
-        if (
-          // Check if http middleware is present, confirming this is a root subsegment
-          (segment as any).http?.request &&
-          // Confirm operation caller didn't do it themselves.
-          // They should, but it's not currently required.
-          !(segment as any).http.request.url.endsWith(segment.name)
-        ) {
-          // @ts-expect-error xray library types suck
-          (segment.http.request.url as string) += '/' + segment.name;
+    return {
+      onExecuteDone: () => {
+        const userId = session$.value?.userId;
+        if (userId) {
+          segment.setUser?.(userId);
         }
 
         return {
-          executionDidEnd: async (err) => {
-            const userId = reqContext.contextValue.session$.value?.userId;
-            if (userId) {
-              segment.setUser?.(userId);
-            }
-
-            if (err) {
-              segment.addError(err);
+          onNext: ({ result }) => {
+            for (const error of result.errors ?? []) {
+              segment.addError(error);
             }
           },
         };
       },
     };
-  }
+  };
 
   fieldMiddleware(): FieldMiddleware {
     return ({ info, args }, next) => {