How mock proper scalar resolvers in v8

[doomsower]

I used this code below to generate mock scalars with stable values. It worked well with @graphql-tools/mock v7:

class CounterMap extends Map<string, number> {
  getNext(key: string): number {
    const current = this.get(key);
    const next = (current || 0) + 1;
    this.set(key, next);
    return next;
  }

  resolveNext(info: GraphQLResolveInfo) {
    const {
      fieldName,
      parentType: { name: parentName },
    } = info;
    const key = `${parentName}.${fieldName}`;
    const seq = this.getNext(key);
    return { key, seq };
  }
}

export interface MockedResolversContext {
  counters: CounterMap;
}

export interface RecursiveMockResolver {
  [name: string]:
    | GraphQLFieldResolver<any, MockedResolversContext>
    | (() => RecursiveMockResolver);
}

export interface MockedProviderOptions {
  Query?: QueryMap;
  Mutation?: QueryMap;
  mocks?: RecursiveMockResolver;
}

const TAG_CATEGORIES = Object.values(TagCategory);

export function mockApolloClient(
  options: MockedProviderOptions = {},
): MockedApolloClient {
  const { Query = {}, Mutation = {}, mocks = {} } = options;
  let schema = makeExecutableSchema({
    typeDefs,
    resolvers: { JSON: JSONResolver },
  });

  const scalarMocks: RecursiveMockResolver = {
    ID: (_, __, { counters }, info) => {
      const { key, seq } = counters.resolveNext(info);
      return `${key}.${seq}`;
    },
    // ...
    Boolean: (_, __, { counters }, info) => {
      const { seq } = counters.resolveNext(info);
      return seq % 2 === 0;
    },
    Coordinates: (_, __, { counters }, info) => {
      const { seq } = counters.resolveNext(info);
      return [seq, seq + 1, seq + 2];
    },
    DateTime: (_, __, { counters }, info) => {
      const { seq } = counters.resolveNext(info);
      const result = new Date(2017, 1, 1);
      result.setDate(result.getDate() + seq);
      return result;
    },
  };

  schema = addMocksToSchema({
    schema,
    mocks: {
      ...scalarMocks,
      ...mocks,
      Query: () => Query,
      Mutation: () => Mutation,
    },
  });

  const countersMap = new CounterMap();
  return Object.assign(
    new ApolloClient({
      cache: configureApolloCache(),
      link: new SchemaLink({ schema, context: { counters: countersMap } }),
    }),
    {
      resetCounters() {
        countersMap.clear();
      },
    },
  );
}

This way I was able to generate mocked data where each object type has stable and predictable field values, for example:

{
    "__typename": "Section",
    "description": "Section.description.1",
    "hidden": false,
    "pois": [
        {
            "__typename": "Point",
            "id": "Point.id.4",
            "name": "Point.name.1",
            "description": "Point.description.1",
            "coordinates": [
                4,
                5,
                6
            ],
            "kind": "Point.kind.4"
        },
        {
            "__typename": "Point",
            "id": "Point.id.5",
            "name": "Point.name.2",
            "description": "Point.description.2",
            "coordinates": [
                5,
                6,
                7
            ],
            "kind": "Point.kind.5"
        }
    ],
    "altNames": [
        "Section.altNames.1",
        "Section.altNames.2"
    ]
}

Having stable and predictable values of mocked scalars allowed me to write tests where I check how different queries interact with each other via apollo cache (merging/overwriting results).

With v8 mocks do not have access to resolver info and context, and resolvers do not resolve scalars.
Any ideas on how I can rewrite this behavior with v8?