@baseplate-dev/fastify-generators 0.1.1

package/dist/generators/vitest/prisma-vitest/templates/prisma.test-helper.ts

@@ -0,0 +1,26 @@
+// @ts-nocheck
+
+import type { PrismaClient } from '@prisma/client';
+import type { DeepMockProxy } from 'vitest-mock-extended';
+
+import { prisma } from '%prismaImports';
+import { beforeEach, vi } from 'vitest';
+import { mockDeep, mockReset } from 'vitest-mock-extended';
+
+vi.mock(TPL_PRISMA_PATH, () => ({
+  __esModule: true,
+  prisma: mockDeep<PrismaClient>(),
+}));
+
+export const prismaMock = prisma as DeepMockProxy<PrismaClient>;
+
+beforeEach(() => {
+  mockReset(prismaMock);
+
+  // mock $transaction
+  prismaMock.$transaction.mockImplementation((promises) =>
+    typeof promises === 'function'
+      ? promises(prismaMock)
+      : Promise.all(promises),
+  );
+});

package/dist/generators/yoga/index.d.ts

@@ -0,0 +1,2 @@
+export * from './yoga-plugin/yoga-plugin.generator.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/generators/yoga/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/generators/yoga/index.ts"],"names":[],"mappings":"AAAA,cAAc,wCAAwC,CAAC"}

package/dist/generators/yoga/index.js

@@ -0,0 +1,2 @@
+export * from './yoga-plugin/yoga-plugin.generator.js';
+//# sourceMappingURL=index.js.map

package/dist/generators/yoga/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/generators/yoga/index.ts"],"names":[],"mappings":"AAAA,cAAc,wCAAwC,CAAC"}

package/dist/generators/yoga/yoga-plugin/generated/ts-templates.d.ts

@@ -0,0 +1,87 @@
+export declare const YOGA_YOGA_PLUGIN_TS_TEMPLATES: {
+    graphqlPlugin: import("@baseplate-dev/core-generators").TsTemplateFile<{
+        TPL_ENVELOP_PLUGINS: {};
+        TPL_GRAPHQL_HANDLER: {};
+        TPL_POST_SCHEMA_FRAGMENTS: {};
+        TPL_SCHEMA: {};
+        TPL_SIDE_EFFECT_IMPORTS: {};
+    }, {
+        configServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            config: {};
+        }>>;
+        errorHandlerServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            BadRequestError: {};
+            ForbiddenError: {};
+            handleZodRequestValidationError: {};
+            HttpError: {};
+            InternalServerError: {};
+            logError: {};
+            NotFoundError: {};
+            UnauthorizedError: {};
+        }>>;
+        loggerServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            logger: {};
+        }>>;
+        requestServiceContextImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            createContextFromRequest: {};
+            RequestServiceContext: {
+                isTypeOnly: true;
+            };
+        }>>;
+    }>;
+    subscriptionsGroup: import("@baseplate-dev/core-generators").TsTemplateGroup<{
+        pubsub: {
+            destination: string;
+            template: import("@baseplate-dev/core-generators").TsTemplateFile<{
+                TPL_PUBLISH_ARGS: {};
+            }, {
+                fastifyRedisImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                    createRedisClient: {};
+                    getRedisClient: {};
+                }>>;
+            }>;
+        };
+        websocket: {
+            destination: string;
+            template: import("@baseplate-dev/core-generators").TsTemplateFile<{
+                TPL_ON_CONNECT: {};
+            }, {
+                errorHandlerServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                    BadRequestError: {};
+                    ForbiddenError: {};
+                    handleZodRequestValidationError: {};
+                    HttpError: {};
+                    InternalServerError: {};
+                    logError: {};
+                    NotFoundError: {};
+                    UnauthorizedError: {};
+                }>>;
+                loggerServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                    logger: {};
+                }>>;
+                requestServiceContextImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                    createContextFromRequest: {};
+                    RequestServiceContext: {
+                        isTypeOnly: true;
+                    };
+                }>>;
+            }>;
+        };
+    }>;
+    useGraphLogger: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {
+        errorHandlerServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            BadRequestError: {};
+            ForbiddenError: {};
+            handleZodRequestValidationError: {};
+            HttpError: {};
+            InternalServerError: {};
+            logError: {};
+            NotFoundError: {};
+            UnauthorizedError: {};
+        }>>;
+        loggerServiceImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            logger: {};
+        }>>;
+    }>;
+};
+//# sourceMappingURL=ts-templates.d.ts.map

package/dist/generators/yoga/yoga-plugin/generated/ts-templates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ts-templates.d.ts","sourceRoot":"","sources":["../../../../../src/generators/yoga/yoga-plugin/generated/ts-templates.ts"],"names":[],"mappings":"AAsEA,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIzC,CAAC"}

package/dist/generators/yoga/yoga-plugin/generated/ts-templates.js

@@ -0,0 +1,66 @@
+import { createTsTemplateFile, createTsTemplateGroup, } from '@baseplate-dev/core-generators';
+import { configServiceImportsProvider } from '../../../core/config-service/generated/ts-import-maps.js';
+import { errorHandlerServiceImportsProvider } from '../../../core/error-handler-service/generated/ts-import-maps.js';
+import { fastifyRedisImportsProvider } from '../../../core/fastify-redis/generated/ts-import-maps.js';
+import { loggerServiceImportsProvider } from '../../../core/logger-service/generated/ts-import-maps.js';
+import { requestServiceContextImportsProvider } from '../../../core/request-service-context/generated/ts-import-maps.js';
+const graphqlPlugin = createTsTemplateFile({
+    importMapProviders: {
+        configServiceImports: configServiceImportsProvider,
+        errorHandlerServiceImports: errorHandlerServiceImportsProvider,
+        loggerServiceImports: loggerServiceImportsProvider,
+        requestServiceContextImports: requestServiceContextImportsProvider,
+    },
+    name: 'graphql-plugin',
+    projectExports: {},
+    source: { path: 'graphql-plugin.ts' },
+    variables: {
+        TPL_ENVELOP_PLUGINS: {},
+        TPL_GRAPHQL_HANDLER: {},
+        TPL_POST_SCHEMA_FRAGMENTS: {},
+        TPL_SCHEMA: {},
+        TPL_SIDE_EFFECT_IMPORTS: {},
+    },
+});
+const pubsub = createTsTemplateFile({
+    group: 'subscriptions',
+    importMapProviders: { fastifyRedisImports: fastifyRedisImportsProvider },
+    name: 'pubsub',
+    projectExports: {},
+    source: { path: 'pubsub.ts' },
+    variables: { TPL_PUBLISH_ARGS: {} },
+});
+const websocket = createTsTemplateFile({
+    group: 'subscriptions',
+    importMapProviders: {
+        errorHandlerServiceImports: errorHandlerServiceImportsProvider,
+        loggerServiceImports: loggerServiceImportsProvider,
+        requestServiceContextImports: requestServiceContextImportsProvider,
+    },
+    name: 'websocket',
+    projectExports: {},
+    source: { path: 'websocket.ts' },
+    variables: { TPL_ON_CONNECT: {} },
+});
+const subscriptionsGroup = createTsTemplateGroup({
+    templates: {
+        pubsub: { destination: 'pubsub.ts', template: pubsub },
+        websocket: { destination: 'websocket.ts', template: websocket },
+    },
+});
+const useGraphLogger = createTsTemplateFile({
+    importMapProviders: {
+        errorHandlerServiceImports: errorHandlerServiceImportsProvider,
+        loggerServiceImports: loggerServiceImportsProvider,
+    },
+    name: 'use-graph-logger',
+    projectExports: {},
+    source: { path: 'use-graph-logger.ts' },
+    variables: {},
+});
+export const YOGA_YOGA_PLUGIN_TS_TEMPLATES = {
+    graphqlPlugin,
+    subscriptionsGroup,
+    useGraphLogger,
+};
+//# sourceMappingURL=ts-templates.js.map

package/dist/generators/yoga/yoga-plugin/generated/ts-templates.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ts-templates.js","sourceRoot":"","sources":["../../../../../src/generators/yoga/yoga-plugin/generated/ts-templates.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,oBAAoB,EACpB,qBAAqB,GACtB,MAAM,gCAAgC,CAAC;AAExC,OAAO,EAAE,4BAA4B,EAAE,MAAM,0DAA0D,CAAC;AACxG,OAAO,EAAE,kCAAkC,EAAE,MAAM,iEAAiE,CAAC;AACrH,OAAO,EAAE,2BAA2B,EAAE,MAAM,yDAAyD,CAAC;AACtG,OAAO,EAAE,4BAA4B,EAAE,MAAM,0DAA0D,CAAC;AACxG,OAAO,EAAE,oCAAoC,EAAE,MAAM,mEAAmE,CAAC;AAEzH,MAAM,aAAa,GAAG,oBAAoB,CAAC;IACzC,kBAAkB,EAAE;QAClB,oBAAoB,EAAE,4BAA4B;QAClD,0BAA0B,EAAE,kCAAkC;QAC9D,oBAAoB,EAAE,4BAA4B;QAClD,4BAA4B,EAAE,oCAAoC;KACnE;IACD,IAAI,EAAE,gBAAgB;IACtB,cAAc,EAAE,EAAE;IAClB,MAAM,EAAE,EAAE,IAAI,EAAE,mBAAmB,EAAE;IACrC,SAAS,EAAE;QACT,mBAAmB,EAAE,EAAE;QACvB,mBAAmB,EAAE,EAAE;QACvB,yBAAyB,EAAE,EAAE;QAC7B,UAAU,EAAE,EAAE;QACd,uBAAuB,EAAE,EAAE;KAC5B;CACF,CAAC,CAAC;AAEH,MAAM,MAAM,GAAG,oBAAoB,CAAC;IAClC,KAAK,EAAE,eAAe;IACtB,kBAAkB,EAAE,EAAE,mBAAmB,EAAE,2BAA2B,EAAE;IACxE,IAAI,EAAE,QAAQ;IACd,cAAc,EAAE,EAAE;IAClB,MAAM,EAAE,EAAE,IAAI,EAAE,WAAW,EAAE;IAC7B,SAAS,EAAE,EAAE,gBAAgB,EAAE,EAAE,EAAE;CACpC,CAAC,CAAC;AAEH,MAAM,SAAS,GAAG,oBAAoB,CAAC;IACrC,KAAK,EAAE,eAAe;IACtB,kBAAkB,EAAE;QAClB,0BAA0B,EAAE,kCAAkC;QAC9D,oBAAoB,EAAE,4BAA4B;QAClD,4BAA4B,EAAE,oCAAoC;KACnE;IACD,IAAI,EAAE,WAAW;IACjB,cAAc,EAAE,EAAE;IAClB,MAAM,EAAE,EAAE,IAAI,EAAE,cAAc,EAAE;IAChC,SAAS,EAAE,EAAE,cAAc,EAAE,EAAE,EAAE;CAClC,CAAC,CAAC;AAEH,MAAM,kBAAkB,GAAG,qBAAqB,CAAC;IAC/C,SAAS,EAAE;QACT,MAAM,EAAE,EAAE,WAAW,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,EAAE;QACtD,SAAS,EAAE,EAAE,WAAW,EAAE,cAAc,EAAE,QAAQ,EAAE,SAAS,EAAE;KAChE;CACF,CAAC,CAAC;AAEH,MAAM,cAAc,GAAG,oBAAoB,CAAC;IAC1C,kBAAkB,EAAE;QAClB,0BAA0B,EAAE,kCAAkC;QAC9D,oBAAoB,EAAE,4BAA4B;KACnD;IACD,IAAI,EAAE,kBAAkB;IACxB,cAAc,EAAE,EAAE;IAClB,MAAM,EAAE,EAAE,IAAI,EAAE,qBAAqB,EAAE;IACvC,SAAS,EAAE,EAAE;CACd,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,6BAA6B,GAAG;IAC3C,aAAa;IACb,kBAAkB;IAClB,cAAc;CACf,CAAC"}

package/dist/generators/yoga/yoga-plugin/templates/graphql-plugin.ts

@@ -0,0 +1,119 @@
+// @ts-nocheck
+
+import type { FastifyReply, FastifyRequest, RouteHandlerMethod } from 'fastify';
+import type { GraphQLErrorOptions } from 'graphql';
+
+import { config } from '%configServiceImports';
+import { HttpError } from '%errorHandlerServiceImports';
+import { logger } from '%loggerServiceImports';
+import { createContextFromRequest } from '%requestServiceContextImports';
+import { requestContext } from '@fastify/request-context';
+import { AltairFastify } from 'altair-fastify-plugin';
+import fp from 'fastify-plugin';
+import { GraphQLError } from 'graphql';
+import { createYoga } from 'graphql-yoga';
+
+TPL_SIDE_EFFECT_IMPORTS;
+
+const IS_DEVELOPMENT = config.APP_ENVIRONMENT === 'development';
+
+const schema = TPL_SCHEMA;
+
+TPL_POST_SCHEMA_FRAGMENTS;
+
+export const graphqlPlugin = fp(async (fastify) => {
+  const graphQLServer = createYoga<{
+    req: FastifyRequest;
+    reply: FastifyReply;
+  }>({
+    logging: logger,
+    context: ({ req, reply }) => createContextFromRequest(req, reply),
+    schema,
+    graphiql: IS_DEVELOPMENT,
+    maskedErrors: {
+      isDev: IS_DEVELOPMENT,
+      maskError: (error, message, isDev) => {
+        if (!(error instanceof GraphQLError)) {
+          return new GraphQLError(message);
+        }
+
+        const { originalError } = error;
+
+        // if we don't have an original error, it's a GraphQL error
+        // which we can just return as-is
+        if (!originalError) {
+          return error;
+        }
+
+        const sharedOptions: GraphQLErrorOptions = {
+          nodes: error.nodes,
+          source: error.source,
+          positions: error.positions,
+          path: error.path,
+        };
+
+        if (originalError instanceof HttpError) {
+          return new GraphQLError(originalError.message, {
+            ...sharedOptions,
+            extensions: {
+              ...error.extensions,
+              code: originalError.code,
+              statusCode: originalError.statusCode,
+              extraData: originalError.extraData,
+              reqId: requestContext.get('reqInfo')?.id,
+            },
+          });
+        }
+
+        return new GraphQLError(message, {
+          ...sharedOptions,
+          extensions: {
+            ...error.extensions,
+            code: 'INTERNAL_SERVER_ERROR',
+            statusCode: 500,
+            reqId: requestContext.get('reqInfo')?.id,
+            originalError: isDev
+              ? {
+                  message: originalError.message,
+                  stack: originalError.stack,
+                }
+              : undefined,
+          },
+        });
+      },
+    },
+    plugins: TPL_ENVELOP_PLUGINS,
+  });
+
+  const httpHandler: RouteHandlerMethod = async (request, reply) => {
+    const response = await graphQLServer.handleNodeRequestAndResponse(
+      request,
+      reply,
+      {
+        req: request,
+        reply,
+      },
+    );
+
+    // Fastify replies with promises that should not be awaited (https://github.com/typescript-eslint/typescript-eslint/issues/2640)
+
+    for (const [key, value] of response.headers.entries()) {
+      reply.header(key, value);
+    }
+
+    reply.status(response.status);
+    reply.send(response.body);
+
+    return reply;
+  };
+
+  TPL_GRAPHQL_HANDLER;
+
+  if (IS_DEVELOPMENT) {
+    await fastify.register(AltairFastify, {
+      path: '/altair',
+      baseURL: '/altair/',
+      endpointURL: '/graphql',
+    });
+  }
+});

package/dist/generators/yoga/yoga-plugin/templates/plugins/graphql/index.ts

@@ -0,0 +1,111 @@
+// @ts-nocheck
+
+import { config } from '%configServiceImports';
+import { HttpError } from '%errorHandlerServiceImports';
+import { logger } from '%loggerServiceImports';
+import { createContextFromRequest } from '%requestServiceContextImports';
+import { requestContext } from '@fastify/request-context';
+import { AltairFastify } from 'altair-fastify-plugin';
+import { FastifyReply, FastifyRequest, RouteHandlerMethod } from 'fastify';
+import fp from 'fastify-plugin';
+import { GraphQLError } from 'graphql';
+import { createYoga } from 'graphql-yoga';
+
+TPL_SIDE_EFFECT_IMPORTS;
+
+const IS_DEVELOPMENT = config.APP_ENVIRONMENT === 'development';
+
+const schema = TPL_SCHEMA;
+
+TPL_POST_SCHEMA_FRAGMENTS;
+
+export const graphqlPlugin = fp(async (fastify) => {
+  const graphQLServer = createYoga<{
+    req: FastifyRequest;
+    reply: FastifyReply;
+  }>({
+    logging: logger,
+    context: ({ req, reply }) => createContextFromRequest(req, reply),
+    schema,
+    graphiql: IS_DEVELOPMENT,
+    maskedErrors: {
+      isDev: IS_DEVELOPMENT,
+      maskError: (error, message, isDev) => {
+        if (!(error instanceof GraphQLError)) {
+          return new GraphQLError(message);
+        }
+
+        const { originalError } = error;
+
+        // if we don't have an original error, it's a GraphQL error
+        // which we can just return as-is
+        if (!originalError) {
+          return error;
+        }
+
+        if (originalError instanceof HttpError) {
+          return new GraphQLError(originalError.message, {
+            ...error,
+            extensions: {
+              ...error.extensions,
+              code: originalError.code,
+              statusCode: originalError.statusCode,
+              extraData: originalError.extraData,
+              reqId: requestContext.get('reqInfo')?.id,
+            },
+          });
+        }
+
+        return new GraphQLError(message, {
+          ...error,
+          extensions: {
+            ...error.extensions,
+            code: 'INTERNAL_SERVER_ERROR',
+            statusCode: 500,
+            reqId: requestContext.get('reqInfo')?.id,
+            originalError: isDev
+              ? {
+                  message: originalError?.message ?? error.message,
+                  stack: originalError?.stack ?? error.stack,
+                }
+              : undefined,
+          },
+        });
+      },
+    },
+    plugins: TPL_ENVELOP_PLUGINS,
+  });
+
+  const httpHandler: RouteHandlerMethod = async (request, reply) => {
+    const response = await graphQLServer.handleNodeRequestAndResponse(
+      request,
+      reply,
+      {
+        req: request,
+        reply,
+      },
+    );
+
+    // Fastify replies with promises that should not be awaited (https://github.com/typescript-eslint/typescript-eslint/issues/2640)
+    /* eslint-disable @typescript-eslint/no-floating-promises */
+
+    response.headers.forEach((value, key) => {
+      reply.header(key, value);
+    });
+
+    reply.status(response.status);
+    reply.send(response.body);
+
+    return reply;
+  };
+
+  TPL_GRAPHQL_HANDLER;
+
+  if (IS_DEVELOPMENT) {
+    await fastify.register(AltairFastify, {
+      path: '/altair',
+      baseURL: '/altair/',
+      endpointURL: '/graphql',
+    });
+  }
+});

package/dist/generators/yoga/yoga-plugin/templates/plugins/graphql/pubsub.ts

@@ -0,0 +1,22 @@
+// @ts-nocheck
+
+import { createRedisClient } from '%fastifyRedisImports';
+import { createRedisEventTarget } from '@graphql-yoga/redis-event-target';
+import { createPubSub, PubSub } from 'graphql-yoga';
+
+// must be a type to be used in the PubSub type
+// eslint-disable-next-line @typescript-eslint/consistent-type-definitions
+type PubSubPublishArgs = TPL_PUBLISH_ARGS;
+
+let cachedPubSub: PubSub<PubSubPublishArgs> | null = null;
+
+export function getPubSub(): PubSub<PubSubPublishArgs> {
+  if (cachedPubSub === null) {
+    const eventTarget = createRedisEventTarget({
+      publishClient: createRedisClient(),
+      subscribeClient: createRedisClient(),
+    });
+    cachedPubSub = createPubSub<PubSubPublishArgs>({ eventTarget });
+  }
+  return cachedPubSub;
+}

package/dist/generators/yoga/yoga-plugin/templates/plugins/graphql/useGraphLogger.ts

@@ -0,0 +1,109 @@
+// @ts-nocheck
+
+import type { OnExecuteDoneHookResultOnNextHookPayload } from '@envelop/types';
+
+import { logError } from '%errorHandlerServiceImports';
+import { logger } from '%loggerServiceImports';
+import { handleStreamOrSingleExecutionResult, Plugin } from '@envelop/core';
+import {
+  DocumentNode,
+  GraphQLError,
+  Kind,
+  OperationDefinitionNode,
+} from 'graphql';
+import { performance } from 'perf_hooks';
+
+function getOperationType(document: DocumentNode): string | undefined {
+  const operationDefinition = document.definitions.find(
+    (d): d is OperationDefinitionNode => d.kind === Kind.OPERATION_DEFINITION,
+  );
+  return operationDefinition?.operation;
+}
+
+interface UseGraphLoggerOptions {
+  logSubscriptionExecution?: boolean;
+  skipLogErrors?: boolean;
+}
+
+export const useGraphLogger = (options?: UseGraphLoggerOptions): Plugin => {
+  const { logSubscriptionExecution, skipLogErrors } = options ?? {};
+  function logResult(
+    { args, result }: OnExecuteDoneHookResultOnNextHookPayload<unknown>,
+    startTime?: number,
+  ): void {
+    const typedArgs = args as {
+      document: DocumentNode;
+      operationName: string;
+    };
+    const operationType = getOperationType(typedArgs.document);
+    const endTime = performance.now();
+
+    const errors = result.errors ?? [];
+
+    if (!skipLogErrors) {
+      errors.forEach((error: GraphQLError) =>
+        logError(error.originalError ?? error),
+      );
+    }
+
+    if (operationType !== 'subscription' || logSubscriptionExecution) {
+      logger.info(
+        {
+          operationType,
+          operationName: typedArgs.operationName,
+          executionTime: startTime && endTime - startTime,
+          success: !errors?.length,
+        },
+        `executed graphql ${operationType ?? 'query'} (${
+          typedArgs.operationName || 'Anonymous Operation'
+        })`,
+      );
+    }
+  }
+  return {
+    // Log parser errors
+    onParse() {
+      return ({ result }) => {
+        if (result instanceof Error) {
+          logger.error(result);
+        }
+      };
+    },
+    // Log validation errors
+    onValidate() {
+      return ({ result, valid }) => {
+        if (!valid) {
+          result.forEach((error: Error) => logger.error(error.message));
+        }
+      };
+    },
+    onExecute() {
+      const startTime = performance.now();
+      return {
+        onExecuteDone(payload) {
+          return handleStreamOrSingleExecutionResult(payload, (p) =>
+            logResult(p, startTime),
+          );
+        },
+      };
+    },
+    onSubscribe({ args }: { args: { operationName?: string } }) {
+      logger.info(
+        { operationName: args.operationName },
+        `graphql subscription started (${
+          args.operationName ?? 'Anonymous Operation'
+        })`,
+      );
+      return {
+        onSubscribeResult(payload) {
+          return handleStreamOrSingleExecutionResult(payload, (p) =>
+            logResult(p),
+          );
+        },
+        onSubscribeError({ error }) {
+          logger.error(error);
+        },
+      };
+    },
+  };
+};