@baseplate-dev/fastify-generators 0.1.3 → 0.2.1

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

@@ -1,87 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,66 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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/plugins/graphql/index.ts

@@ -1,111 +0,0 @@
-// @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

@@ -1,22 +0,0 @@
-// @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

@@ -1,109 +0,0 @@
-// @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);
-        },
-      };
-    },
-  };
-};

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

@@ -1,256 +0,0 @@
-// @ts-nocheck
-
-import { logError } from '%errorHandlerServiceImports';
-import { logger } from '%loggerServiceImports';
-import { createContextFromRequest } from '%requestServiceContextImports';
-import { WebsocketHandler } from '@fastify/websocket';
-import { FastifyReply, FastifyRequest } from 'fastify';
-import { ExecutionArgs, ExecutionResult, GraphQLError } from 'graphql';
-import {
-  CloseCode,
-  ConnectionInitMessage,
-  DEPRECATED_GRAPHQL_WS_PROTOCOL,
-  handleProtocols,
-  makeServer,
-  ServerOptions,
-} from 'graphql-ws';
-import { YogaServerInstance } from 'graphql-yoga';
-import * as ws from 'ws';
-
-interface RootValueWithExecutor {
-  execute: (args: ExecutionArgs) => Promise<ExecutionResult>;
-  subscribe: (args: ExecutionArgs) => Promise<ExecutionResult>;
-}
-
-/**
- * The extra that will be put in the `Context`.
- */
-interface Extra {
-  /**
-   * The underlying socket between the server and the client.
-   */
-  readonly socket: ws.WebSocket;
-  /**
-   * The initial HTTP upgrade request before the actual
-   * socket and connection is established.
-   */
-  readonly request: FastifyRequest;
-}
-
-/**
- * Make a handler to use on a [@fastify/websocket](https://github.com/fastify/fastify-websocket) route.
- *
- * This has been adapted from the graphql-ws version due to https://github.com/enisdenjo/graphql-ws/issues/553.
- */
-export function makeHandler<
-  P extends ConnectionInitMessage['payload'] = ConnectionInitMessage['payload'],
-  E extends Record<PropertyKey, unknown> = Record<PropertyKey, never>,
->(
-  options: ServerOptions<P, Extra & Partial<E>>,
-  /**
-   * The timout between dispatched keep-alive messages. Internally uses the [ws Ping and Pongs](https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API/Writing_WebSocket_servers#pings_and_pongs_the_heartbeat_of_websockets)
-   * to check that the link between the clients and the server is operating and to prevent the link
-   * from being broken due to idling.
-   *
-   * @default 12_000 // 12 seconds
-   */
-  keepAlive = 12_000,
-): WebsocketHandler {
-  const isProd = process.env.NODE_ENV === 'production';
-  const server = makeServer(options);
-
-  // we dont have access to the fastify-websocket server instance yet,
-  // register an error handler on first connection ONCE only
-  let handlingServerEmittedErrors = false;
-
-  return function handler(socket, request) {
-    // might be too late, but meh
-    this.websocketServer.options.handleProtocols = handleProtocols;
-
-    // handle server emitted errors only if not already handling
-    if (!handlingServerEmittedErrors) {
-      handlingServerEmittedErrors = true;
-      this.websocketServer.once('error', (err) => {
-        logger.error(
-          'Internal error emitted on the WebSocket server. ' +
-            'Please check your implementation.',
-          err,
-        );
-
-        // catch the first thrown error and re-throw it once all clients have been notified
-        let firstErr: unknown = null;
-
-        // report server errors by erroring out all clients with the same error
-        for (const client of this.websocketServer.clients) {
-          try {
-            client.close(
-              CloseCode.InternalServerError,
-              isProd
-                ? 'Internal server error'
-                : (err instanceof Error ? err.message : String(err)).slice(
-                    0,
-                    1024,
-                  ),
-            );
-          } catch (err) {
-            firstErr = firstErr ?? err;
-          }
-        }
-
-        if (firstErr) throw firstErr;
-      });
-    }
-
-    // used as listener on two streams, prevent superfluous calls on close
-    let emittedErrorHandled = false;
-    function handleEmittedError(err: Error): void {
-      if (emittedErrorHandled) return;
-      emittedErrorHandled = true;
-      logError(err, {
-        context:
-          'Internal error emitted on a WebSocket socket. ' +
-          'Please check your implementation.',
-      });
-      socket.close(
-        CloseCode.InternalServerError,
-        isProd
-          ? 'Internal server error'
-          : (err instanceof Error ? err.message : String(err)).slice(0, 1024),
-      );
-    }
-
-    // fastify-websocket uses the WebSocket.createWebSocketStream,
-    // therefore errors get emitted on both the connection and the socket
-    socket.once('error', handleEmittedError);
-
-    // keep alive through ping-pong messages
-    let pongWait: ReturnType<typeof setTimeout> | null = null;
-    const pingInterval =
-      keepAlive > 0 && isFinite(keepAlive)
-        ? setInterval(() => {
-            // ping pong on open sockets only
-            if (socket.readyState === socket.OPEN) {
-              // terminate the connection after pong wait has passed because the client is idle
-              pongWait = setTimeout(() => {
-                socket.terminate();
-              }, keepAlive);
-
-              // listen for client's pong and stop socket termination
-              socket.once('pong', () => {
-                if (pongWait) {
-                  clearTimeout(pongWait);
-                  pongWait = null;
-                }
-              });
-
-              socket.ping();
-            }
-          }, keepAlive)
-        : null;
-
-    const closed = server.opened(
-      {
-        protocol: socket.protocol,
-        send: (data) =>
-          new Promise((resolve, reject) => {
-            if (socket.readyState !== socket.OPEN) return resolve();
-            socket.send(data, (err) => (err ? reject(err) : resolve()));
-          }),
-        close: (code, reason) => socket.close(code, reason),
-        onMessage: (cb) =>
-          socket.on('message', (event) => {
-            cb(String(event)).catch((err) => {
-              logError(err, {
-                context:
-                  'Internal error occurred during message handling. ' +
-                  'Please check your implementation.',
-              });
-              socket.close(
-                CloseCode.InternalServerError,
-                isProd
-                  ? 'Internal server error'
-                  : (err instanceof Error ? err.message : String(err)).slice(
-                      0,
-                      1024,
-                    ),
-              );
-            });
-          }),
-      },
-      { socket, request } as Extra & Partial<E>,
-    );
-
-    socket.once('close', (code, reason) => {
-      if (pongWait) clearTimeout(pongWait);
-      if (pingInterval) clearInterval(pingInterval);
-      if (
-        !isProd &&
-        code === (CloseCode.SubprotocolNotAcceptable as number) &&
-        socket.protocol === DEPRECATED_GRAPHQL_WS_PROTOCOL
-      )
-        logger.warn(
-          `Client provided the unsupported and deprecated subprotocol "${socket.protocol}" used by subscriptions-transport-ws.` +
-            'Please see https://www.apollographql.com/docs/apollo-server/data/subscriptions/#switching-from-subscriptions-transport-ws.',
-        );
-      closed(code, String(reason)).catch((err) => logError(err));
-    });
-  };
-}
-
-export function getGraphqlWsHandler(
-  graphQLServer: YogaServerInstance<
-    {
-      req: FastifyRequest;
-      reply: FastifyReply;
-    },
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    any
-  >,
-): WebsocketHandler {
-  return makeHandler({
-    execute: (args) => (args.rootValue as RootValueWithExecutor).execute(args),
-    TPL_ON_CONNECT,
-
-    subscribe: (args) =>
-      (args.rootValue as RootValueWithExecutor).subscribe(args),
-    onSubscribe: (ctx, msg) => {
-      try {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        const { schema, execute, subscribe, parse, validate } =
-          graphQLServer.getEnveloped({
-            ...ctx,
-            req: ctx.extra.request,
-            socket: ctx.extra.socket,
-            params: msg.payload,
-          });
-
-        const args = {
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-          schema,
-          operationName: msg.payload.operationName,
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-          document: parse(msg.payload.query),
-          variableValues: msg.payload.variables,
-          contextValue: createContextFromRequest(ctx.extra.request),
-          rootValue: {
-            execute,
-            subscribe,
-          },
-        };
-
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        const errors = validate(args.schema, args.document);
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-return
-        if (errors.length) return errors;
-        return args;
-      } catch (err) {
-        logError(err);
-        return [
-          new GraphQLError('Error creating subscription', {
-            originalError: err as Error,
-          }),
-        ];
-      }
-    },
-  });
-}