Impossible to use mocks the suggested official way after the dependency was upgraded to Apollo Server 4 about graphql

[vnenkpet]

Nevermind. I think I figured it out, we can just write an Apollo Server Plugin which does the trick:

import {
  ApolloServerPlugin,
  GraphQLRequestContext,
  GraphQLRequestContextWillSendResponse,
  GraphQLRequestListener,
} from '@apollo/server';
import { addMocksToSchema } from '@graphql-tools/mock';
import { Logger } from '@nestjs/common';
import { graphql } from 'graphql';

export class MocksApolloPlugin implements ApolloServerPlugin {
  private readonly logger = new Logger(MocksApolloPlugin.name);

  private readonly resolvers: Record<string, any> | undefined;
  private readonly mocks: Record<string, any> | undefined;

  constructor({
    resolvers,
    mocks,
  }: {
    resolvers?: Record<string, any>;
    mocks?: Record<string, any>;
  }) {
    this.resolvers = resolvers;
    this.mocks = mocks;
  }

  async requestDidStart(
    requestContext: GraphQLRequestContext<any>,
  ): Promise<GraphQLRequestListener<any>> {
    const resolvers = this.resolvers;
    const mocks = this.mocks;

    return {
      async willSendResponse(
        requestContext: GraphQLRequestContextWillSendResponse<any>,
      ) {
        const mockedSchema = addMocksToSchema({
          schema: requestContext.schema,
          resolvers,
          mocks,
          preserveResolvers: false,
        });
        if (requestContext.response.body.kind === 'single') {
          const result = await graphql({
            schema: mockedSchema,
            source: requestContext.source,
            variableValues: requestContext.request.variables,
          });
          requestContext.response.body.singleResult.data = (result.data ||
            {}) as Record<string, unknown>;
        }
      },
    };
  }
}

and then just add it to the "plugins" field of the GraphQLModule, eg:

          plugins: [
            ApolloServerPluginLandingPageLocalDefault({
              includeCookies: true,
              embed: true,
            }),
            new MocksApolloPlugin({
              resolvers: mockResolvers,
            }),
          ],

[vnenkpet]

I guess it would be nice to have this mentioned somewhere in the docs.

[vnenkpet]

Actually, just noticed my solution isn't exactly right, because while it does return mocked response, but it still executes the actual resolver. I suppose it should be doable though.

[vnenkpet]

This seems to be so far doing what I want:

import {
  ApolloServerPlugin,
  GraphQLRequestContext,
  GraphQLRequestContextResponseForOperation,
  GraphQLRequestListener,
  GraphQLResponse,
  HeaderMap,
} from '@apollo/server';
import { addMocksToSchema } from '@graphql-tools/mock';
import { Logger } from '@nestjs/common';
import { graphql } from 'graphql';

export class MocksApolloPlugin implements ApolloServerPlugin {
  private readonly logger = new Logger(MocksApolloPlugin.name);

  private readonly resolvers: Record<string, any> | undefined;
  private readonly mocks: Record<string, any> | undefined;
  private readonly isEnabled: boolean;

  constructor({
    resolvers,
    mocks,
    isEnabled,
  }: {
    resolvers?: Record<string, any>;
    mocks?: Record<string, any>;
    isEnabled: boolean;
  }) {
    this.resolvers = resolvers;
    this.mocks = mocks;
    this.isEnabled = isEnabled;
  }

  async requestDidStart(
    requestContext: GraphQLRequestContext<any>,
  ): Promise<GraphQLRequestListener<any>> {
    const resolvers = this.resolvers;
    const mocks = this.mocks;
    const isEnabled = this.isEnabled;

    return {
      async responseForOperation(
        requestContext: GraphQLRequestContextResponseForOperation<any>,
      ): Promise<GraphQLResponse | null> {
        if (!isEnabled) {
          return null;
        }

        const mockedSchema = addMocksToSchema({
          schema: requestContext.schema,
          resolvers,
          mocks,
          preserveResolvers: false,
        });

        const result = await graphql({
          schema: mockedSchema,
          source: requestContext.source,
          variableValues: requestContext.request.variables,
        });

        return {
          body: { kind: 'single', singleResult: { data: result.data || {} } },
          http: { headers: new HeaderMap() },
        };
      },
    };
  }
}

[vnenkpet]

Alternatively I also found out it's possible to simply do this:

    schema: addMocksToSchema({
      schema: makeExecutableSchema({
        typeDefs: await readFile('src/schema.gql', 'utf-8'),
      }),
      mocks: graphqlMocks,
    }),

Closing then.