or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

index.mdlist-mocking.mdmock-server.mdmock-store.mdpagination.mdschema-mocking.md
tile.json

tessl/npm-graphql-tools--mock

GraphQL schema mocking utilities with stateful stores and realistic test data generation

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
npmpkg:npm/@graphql-tools/mock@9.0.x

To install, run

npx @tessl/cli install tessl/npm-graphql-tools--mock@9.0.0

index.mddocs/

GraphQL Tools Mock

GraphQL Tools Mock provides comprehensive utilities for creating mock implementations of GraphQL schemas during development and testing. It enables developers to generate realistic test data, maintain stateful mock stores for consistent queries, and create mock servers without implementing full resolvers.

Package Information

  • Package Name: @graphql-tools/mock
  • Package Type: npm
  • Language: TypeScript
  • Installation: npm install @graphql-tools/mock
  • Node Version: >=16.0.0

Core Imports

import { 
  addMocksToSchema, 
  createMockStore, 
  MockStore, 
  MockList,
  mockServer,
  relayStylePaginationMock,
  isRef,
  assertIsRef,
  makeRef
} from "@graphql-tools/mock";

// defaultMocks is also available from the main export:
import { defaultMocks } from "@graphql-tools/mock";

For CommonJS:

const { 
  addMocksToSchema, 
  createMockStore, 
  MockStore, 
  MockList,
  mockServer,
  relayStylePaginationMock,
  isRef,
  assertIsRef,
  makeRef
} = require("@graphql-tools/mock");

// defaultMocks is also available from the main export:
const { defaultMocks } = require("@graphql-tools/mock");

Basic Usage

import { buildSchema } from "graphql";
import { addMocksToSchema, createMockStore } from "@graphql-tools/mock";

// Create a simple schema
const schema = buildSchema(`
  type User {
    id: ID!
    name: String!
    email: String!
  }

  type Query {
    user(id: ID!): User
    users: [User!]!
  }
`);

// Add mocks to schema with custom mock functions
const mockedSchema = addMocksToSchema({
  schema,
  mocks: {
    User: () => ({
      id: () => Math.random().toString(36).substr(2, 9),
      name: () => ['Alice', 'Bob', 'Charlie'][Math.floor(Math.random() * 3)],
      email: () => 'user@example.com'
    })
  }
});

// Use a stateful mock store for consistent data
const store = createMockStore({ schema });
const mockedSchemaWithStore = addMocksToSchema({
  schema,
  store
});

Architecture

GraphQL Tools Mock is built around several key components:

  • Schema Enhancement: addMocksToSchema transforms existing schemas by adding mock resolvers
  • Stateful Storage: MockStore provides consistent data across multiple queries with reference tracking
  • Mock Generation: Built-in and custom mock functions for generating realistic test data
  • Server Utilities: Quick mock server creation for testing and development
  • List Handling: MockList for generating arrays with controlled length and content
  • Pagination Support: Relay-style pagination utilities for connection fields

Capabilities

Schema Mocking

Core schema mocking functionality that adds mock resolvers to GraphQL schemas. Essential for development servers and testing environments where you need realistic data without backend implementation.

function addMocksToSchema<TResolvers = IResolvers>({
  schema,
  store?: IMockStore,
  mocks?: IMocks<TResolvers>,
  typePolicies?: { [typeName: string]: TypePolicy },
  resolvers?: Partial<TResolvers> | ((store: IMockStore) => Partial<TResolvers>),
  preserveResolvers?: boolean
}: IMockOptions<TResolvers>): GraphQLSchema;

interface IMockOptions<TResolvers> {
  schema: GraphQLSchema;
  store?: IMockStore;
  mocks?: IMocks<TResolvers>;
  typePolicies?: { [typeName: string]: TypePolicy };
  resolvers?: Partial<TResolvers> | ((store: IMockStore) => Partial<TResolvers>);
  preserveResolvers?: boolean;
}

Schema Mocking

Mock Store

Stateful storage system for consistent mock data across queries. Provides reference tracking, data persistence, and advanced querying capabilities for complex testing scenarios.

class MockStore implements IMockStore {
  constructor(options: {
    schema: GraphQLSchema;
    mocks?: IMocks;
    typePolicies?: { [typeName: string]: TypePolicy };
  });
  
  get<KeyT extends KeyTypeConstraints = string>(
    typeName: string,
    key?: KeyT,
    defaultValue?: { [fieldName: string]: any }
  ): unknown | Ref<KeyT>;
  
  set<KeyT extends KeyTypeConstraints = string>(
    typeName: string,
    key: KeyT,
    values: { [fieldName: string]: any }
  ): void;
  
  has<KeyT extends KeyTypeConstraints = string>(typeName: string, key: KeyT): boolean;
  reset(): void;
}

function createMockStore(options: {
  schema: GraphQLSchema;
  mocks?: IMocks;
  typePolicies?: { [typeName: string]: TypePolicy };
}): IMockStore;

Mock Store

Mock Server

Quick mock server creation for testing and development. Provides a simple interface for executing queries against mocked schemas without complex setup.

function mockServer<TResolvers>(
  schema: TypeSource,
  mocks: IMocks<TResolvers>,
  preserveResolvers?: boolean
): IMockServer;

interface IMockServer {
  query: (query: string, vars?: Record<string, any>) => Promise<ExecutionResult>;
}

Mock Server

List Mocking

Specialized utilities for mocking array and list fields with controlled length and content generation.

class MockList {
  constructor(length: number | Array<number>, mockFunction?: () => unknown);
  mock(): Array<unknown>;
}

function isMockList(obj: any): obj is MockList;
function deepResolveMockList(mockList: MockList): unknown[];

List Mocking

Pagination Support

Relay-style pagination utilities for implementing cursor-based pagination in mock resolvers.

const relayStylePaginationMock: <TContext, TArgs extends RelayPaginationParams>(
  store: IMockStore,
  options?: RelayStylePaginationMockOptions<TContext, TArgs>
) => IFieldResolver<Ref, TContext, TArgs, any>;

type RelayPaginationParams = {
  first?: number;
  after?: string;
  last?: number;
  before?: string;
};

Pagination

Utility Functions

Helper utilities for working with references, data validation, and mock generation.

function isRef<KeyT extends KeyTypeConstraints = string>(
  maybeRef: unknown
): maybeRef is Ref<KeyT>;

function assertIsRef<KeyT extends KeyTypeConstraints = string>(
  maybeRef: unknown,
  message?: string
): asserts maybeRef is Ref<KeyT>;

function makeRef<KeyT extends KeyTypeConstraints = string>(
  typeName: string,
  key: KeyT
): Ref<KeyT>;

function isRecord(obj: unknown): obj is { [key: string]: unknown };

function uuidv4(): string;

const randomListLength: () => number;
const takeRandom: <T>(arr: T[]) => T;

Core Types

// Mock Configuration Types
type IMocks<TResolvers = IResolvers> = {
  [TTypeName in keyof TResolvers]?: {
    [TFieldName in keyof TResolvers[TTypeName]]: 
      TResolvers[TTypeName][TFieldName] extends (args: any) => any
        ? () => ReturnType<TResolvers[TTypeName][TFieldName]> | ReturnType<TResolvers[TTypeName][TFieldName]>
        : TResolvers[TTypeName][TFieldName];
  };
} & {
  [typeOrScalarName: string]: IScalarMock | ITypeMock;
};

type IScalarMock = unknown | IMockFn;
type ITypeMock = () => { [fieldName: string]: unknown | IMockFn };
type IMockFn = () => unknown;

// Reference Types
type Ref<KeyT extends KeyTypeConstraints = string> = {
  $ref: {
    key: KeyT;
    typeName: string;
  };
};

type KeyTypeConstraints = string | number;

// Type Policy Configuration
type TypePolicy = {
  keyFieldName?: string | false;
};

// Store Interface
interface IMockStore {
  schema: GraphQLSchema;
  get<KeyT extends KeyTypeConstraints = string>(
    typeName: string,
    key?: KeyT,
    defaultValue?: { [fieldName: string]: any }
  ): unknown | Ref<KeyT>;
  set<KeyT extends KeyTypeConstraints = string>(
    typeName: string,
    key: KeyT,
    values: { [fieldName: string]: any }
  ): void;
  has<KeyT extends KeyTypeConstraints = string>(typeName: string, key: KeyT): boolean;
  reset(): void;
}