@graphql-tools/mock 8.7.2-alpha-e7752ba5.0 → 8.7.2-alpha-b9e4a92b.0

package/cjs/MockStore.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createMockStore = exports.MockStore = exports.defaultMocks = void 0;
 const tslib_1 = require("tslib");
-const graphql_1 = require("@graphql-tools/graphql");
+const graphql_1 = require("graphql");
 const fast_json_stable_stringify_1 = tslib_1.__importDefault(require("fast-json-stable-stringify"));
 const types_js_1 = require("./types.js");
 const utils_js_1 = require("./utils.js");

package/cjs/addMocksToSchema.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.addMocksToSchema = void 0;
-const graphql_1 = require("@graphql-tools/graphql");
+const graphql_1 = require("graphql");
 const utils_1 = require("@graphql-tools/utils");
 const schema_1 = require("@graphql-tools/schema");
 const types_js_1 = require("./types.js");

package/cjs/mockServer.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mockServer = void 0;
-const graphql_1 = require("@graphql-tools/graphql");
+const graphql_1 = require("graphql");
 const schema_1 = require("@graphql-tools/schema");
 const addMocksToSchema_js_1 = require("./addMocksToSchema.js");
 /**

package/esm/MockStore.js

@@ -1,4 +1,4 @@
-import { GraphQLString, isObjectType, isScalarType, getNullableType, isListType, isEnumType, isAbstractType, isCompositeType, isNullableType, isInterfaceType, } from '@graphql-tools/graphql';
+import { GraphQLString, isObjectType, isScalarType, getNullableType, isListType, isEnumType, isAbstractType, isCompositeType, isNullableType, isInterfaceType, } from 'graphql';
 import stringify from 'fast-json-stable-stringify';
 import { isRef, assertIsRef, isRecord, } from './types.js';
 import { uuidv4, randomListLength, takeRandom, makeRef } from './utils.js';

package/esm/addMocksToSchema.js

@@ -1,4 +1,4 @@
-import { defaultFieldResolver, isUnionType, GraphQLUnionType, GraphQLInterfaceType, isSchema, } from '@graphql-tools/graphql';
+import { defaultFieldResolver, isUnionType, GraphQLUnionType, GraphQLInterfaceType, isSchema, } from 'graphql';
 import { mapSchema, MapperKind } from '@graphql-tools/utils';
 import { addResolversToSchema } from '@graphql-tools/schema';
 import { isRef } from './types.js';

package/esm/mockServer.js

@@ -1,4 +1,4 @@
-import { isSchema, graphql } from '@graphql-tools/graphql';
+import { isSchema, graphql } from 'graphql';
 import { makeExecutableSchema } from '@graphql-tools/schema';
 import { addMocksToSchema } from './addMocksToSchema.js';
 /**

package/package.json

@@ -1,12 +1,14 @@
 {
   "name": "@graphql-tools/mock",
-  "version": "8.7.2-alpha-e7752ba5.0",
+  "version": "8.7.2-alpha-b9e4a92b.0",
   "description": "A set of utils for faster development of GraphQL tools",
   "sideEffects": false,
+  "peerDependencies": {
+    "graphql": "^14.0.0 || ^15.0.0 || ^16.0.0 || ^17.0.0"
+  },
   "dependencies": {
-    "@graphql-tools/schema": "8.5.2-alpha-e7752ba5.0",
-    "@graphql-tools/utils": "8.9.1-alpha-e7752ba5.0",
-    "@graphql-tools/graphql": "0.1.0-alpha-e7752ba5.0",
+    "@graphql-tools/schema": "8.5.2-alpha-b9e4a92b.0",
+    "@graphql-tools/utils": "8.9.1-alpha-b9e4a92b.0",
     "fast-json-stable-stringify": "^2.1.0",
     "tslib": "^2.4.0"
   },
@@ -26,7 +28,7 @@
   "exports": {
     ".": {
       "require": {
-        "types": "./typings/index.d.ts",
+        "types": "./typings/index.d.cts",
         "default": "./cjs/index.js"
       },
       "import": {
@@ -40,7 +42,7 @@
     },
     "./*": {
       "require": {
-        "types": "./typings/*.d.ts",
+        "types": "./typings/*.d.cts",
         "default": "./cjs/*.js"
       },
       "import": {

package/typings/MockList.d.cts

@@ -0,0 +1,25 @@
+/**
+ * @internal
+ */
+export declare function isMockList(obj: any): obj is MockList;
+/**
+ * This is an object you can return from your mock resolvers which calls the
+ * provided `mockFunction` once for each list item.
+ */
+export declare class MockList {
+    private readonly len;
+    private readonly wrappedFunction;
+    /**
+     * @param length Either the exact length of items to return or an inclusive
+     * range of possible lengths.
+     * @param mockFunction The function to call for each item in the list to
+     * resolve it. It can return another MockList or a value.
+     */
+    constructor(length: number | Array<number>, mockFunction?: () => unknown);
+    /**
+     * @internal
+     */
+    mock(): unknown[];
+    private randint;
+}
+export declare function deepResolveMockList(mockList: MockList): unknown[];

package/typings/MockStore.d.cts

@@ -0,0 +1,94 @@
+import { GraphQLSchema } from 'graphql';
+import { IMockStore, GetArgs, SetArgs, Ref, TypePolicy, IMocks, KeyTypeConstraints } from './types.cjs';
+export declare const defaultMocks: {
+    Int: () => number;
+    Float: () => number;
+    String: () => string;
+    Boolean: () => boolean;
+    ID: () => string;
+};
+declare type Entity = {
+    [key: string]: unknown;
+};
+export declare class MockStore implements IMockStore {
+    schema: GraphQLSchema;
+    private mocks;
+    private typePolicies;
+    private store;
+    constructor({ schema, mocks, typePolicies, }: {
+        schema: GraphQLSchema;
+        mocks?: IMocks;
+        typePolicies?: {
+            [typeName: string]: TypePolicy;
+        };
+    });
+    has<KeyT extends KeyTypeConstraints = string>(typeName: string, key: KeyT): boolean;
+    get<KeyT extends KeyTypeConstraints = string, ReturnKeyT extends KeyTypeConstraints = string>(_typeName: string | Ref<KeyT> | GetArgs<KeyT>, _key?: KeyT | {
+        [fieldName: string]: any;
+    } | string | string[], _fieldName?: string | string[] | {
+        [fieldName: string]: any;
+    } | string | {
+        [argName: string]: any;
+    }, _fieldArgs?: string | {
+        [argName: string]: any;
+    }): unknown | Ref<ReturnKeyT>;
+    set<KeyT extends KeyTypeConstraints>(_typeName: string | Ref<KeyT> | SetArgs<KeyT>, _key?: KeyT | string | {
+        [fieldName: string]: any;
+    }, _fieldName?: string | {
+        [fieldName: string]: any;
+    } | unknown, _value?: unknown): void;
+    reset(): void;
+    filter(key: string, predicate: (val: Entity) => boolean): Entity[];
+    find(key: string, predicate: (val: Entity) => boolean): Entity | undefined;
+    private getImpl;
+    private setImpl;
+    private normalizeValueToStore;
+    private insert;
+    private generateFieldValue;
+    private generateFieldValueFromMocks;
+    private generateKeyForType;
+    private generateValueFromType;
+    private getFieldType;
+    private getType;
+    private isKeyField;
+    private getKeyFieldName;
+}
+/**
+ * Will create `MockStore` for the given `schema`.
+ *
+ * A `MockStore` will generate mock values for the given schem when queried.
+ *
+ * It will stores generated mocks, so that, provided with same arguments
+ * the returned values will be the same.
+ *
+ * Its API also allows to modify the stored values.
+ *
+ * Basic example:
+ * ```ts
+ * store.get('User', 1, 'name');
+ * // > "Hello World"
+ * store.set('User', 1, 'name', 'Alexandre');
+ * store.get('User', 1, 'name');
+ * // > "Alexandre"
+ * ```
+ *
+ * The storage key will correspond to the "key field"
+ * of the type. Field with name `id` or `_id` will be
+ * by default considered as the key field for the type.
+ * However, use `typePolicies` to precise the field to use
+ * as key.
+ */
+export declare function createMockStore(options: {
+    /**
+     * The `schema` to based mocks on.
+     */
+    schema: GraphQLSchema;
+    /**
+     * The mocks functions to use.
+     */
+    mocks?: IMocks;
+    typePolicies?: {
+        [typeName: string]: TypePolicy;
+    };
+}): IMockStore;
+export {};

package/typings/MockStore.d.ts

@@ -1,4 +1,4 @@
-import { GraphQLSchema } from '@graphql-tools/graphql';
+import { GraphQLSchema } from 'graphql';
 import { IMockStore, GetArgs, SetArgs, Ref, TypePolicy, IMocks, KeyTypeConstraints } from './types.js';
 export declare const defaultMocks: {
     Int: () => number;

package/typings/addMocksToSchema.d.cts

@@ -0,0 +1,78 @@
+import { GraphQLSchema } from 'graphql';
+import { IResolvers } from '@graphql-tools/utils';
+import { IMockStore, IMocks, TypePolicy } from './types.cjs';
+declare type IMockOptions<TResolvers = IResolvers> = {
+    schema: GraphQLSchema;
+    store?: IMockStore;
+    mocks?: IMocks<TResolvers>;
+    typePolicies?: {
+        [typeName: string]: TypePolicy;
+    };
+    resolvers?: Partial<TResolvers> | ((store: IMockStore) => Partial<TResolvers>);
+    /**
+     * Set to `true` to prevent existing resolvers from being
+     * overwritten to provide mock data. This can be used to mock some parts of the
+     * server and not others.
+     */
+    preserveResolvers?: boolean;
+};
+/**
+ * Given a `schema` and a `MockStore`, returns an executable schema that
+ * will use the provided `MockStore` to execute queries.
+ *
+ * ```ts
+ * const schema = buildSchema(`
+ *  type User {
+ *    id: ID!
+ *    name: String!
+ *  }
+ *  type Query {
+ *    me: User!
+ *  }
+ * `)
+ *
+ * const store = createMockStore({ schema });
+ * const mockedSchema = addMocksToSchema({ schema, store });
+ * ```
+ *
+ *
+ * If a `resolvers` parameter is passed, the query execution will use
+ * the provided `resolvers` if, one exists, instead of the default mock
+ * resolver.
+ *
+ *
+ * ```ts
+ * const schema = buildSchema(`
+ *   type User {
+ *     id: ID!
+ *     name: String!
+ *   }
+ *   type Query {
+ *     me: User!
+ *   }
+ *   type Mutation {
+ *     setMyName(newName: String!): User!
+ *   }
+ * `)
+ *
+ * const store = createMockStore({ schema });
+ * const mockedSchema = addMocksToSchema({
+ *   schema,
+ *   store,
+ *   resolvers: {
+ *     Mutation: {
+ *       setMyName: (_, { newName }) => {
+ *          const ref = store.get('Query', 'ROOT', 'viewer');
+ *          store.set(ref, 'name', newName);
+ *          return ref;
+ *       }
+ *     }
+ *   }
+ *  });
+ * ```
+ *
+ *
+ * `Query` and `Mutation` type will use `key` `'ROOT'`.
+ */
+export declare function addMocksToSchema<TResolvers = IResolvers>({ schema, store: maybeStore, mocks, typePolicies, resolvers: resolversOrFnResolvers, preserveResolvers, }: IMockOptions<TResolvers>): GraphQLSchema;
+export {};

package/typings/addMocksToSchema.d.ts

@@ -1,4 +1,4 @@
-import { GraphQLSchema } from '@graphql-tools/graphql';
+import { GraphQLSchema } from 'graphql';
 import { IResolvers } from '@graphql-tools/utils';
 import { IMockStore, IMocks, TypePolicy } from './types.js';
 declare type IMockOptions<TResolvers = IResolvers> = {

package/typings/index.d.cts

@@ -0,0 +1,6 @@
+export * from './MockStore.cjs';
+export * from './addMocksToSchema.cjs';
+export * from './mockServer.cjs';
+export * from './types.cjs';
+export * from './MockList.cjs';
+export * from './pagination.cjs';

package/typings/mockServer.d.cts

@@ -0,0 +1,15 @@
+import { TypeSource } from '@graphql-tools/utils';
+import { IMockServer, IMocks } from './types.cjs';
+/**
+ * A convenience wrapper on top of addMocksToSchema. It adds your mock resolvers
+ * to your schema and returns a client that will correctly execute your query with
+ * variables. Note: when executing queries from the returned server, context and
+ * root will both equal `{}`.
+ * @param schema The schema to which to add mocks. This can also be a set of type
+ * definitions instead.
+ * @param mocks The mocks to add to the schema.
+ * @param preserveResolvers Set to `true` to prevent existing resolvers from being
+ * overwritten to provide mock data. This can be used to mock some parts of the
+ * server and not others.
+ */
+export declare function mockServer<TResolvers>(schema: TypeSource, mocks: IMocks<TResolvers>, preserveResolvers?: boolean): IMockServer;

package/typings/pagination.d.cts

@@ -0,0 +1,86 @@
+import { IFieldResolver } from '@graphql-tools/utils';
+import { GraphQLResolveInfo } from 'graphql';
+import { IMockStore, Ref } from './types.cjs';
+export declare type AllNodesFn<TContext, TArgs extends RelayPaginationParams> = (parent: Ref, args: TArgs, context: TContext, info: GraphQLResolveInfo) => Ref[];
+export declare type RelayStylePaginationMockOptions<TContext, TArgs extends RelayPaginationParams> = {
+    /**
+     * Use this option to apply filtering or sorting on the nodes given the
+     * arguments the paginated field receives.
+     *
+     * ```ts
+     * {
+     *    User: {
+     *      friends: mockedRelayStylePagination<
+     *        unknown,
+     *        RelayPaginationParams & { sortByBirthdateDesc?: boolean}
+     *      >(
+     *        store, {
+     *          applyOnEdges: (edges, { sortByBirthdateDesc }) => {
+     *            if (!sortByBirthdateDesc) return edges
+     *            return _.sortBy(edges, (e) => store.get(e, ['node', 'birthdate']))
+     *          }
+     *       }),
+     *    }
+     * }
+     * ```
+     */
+    applyOnNodes?: (nodeRefs: Ref[], args: TArgs) => Ref[];
+    /**
+     * A function that'll be used to get all the nodes used for pagination.
+     *
+     * By default, it will use the nodes of the field this pagination is attached to.
+     *
+     * This option is handy when several paginable fields should share
+     * the same base nodes:
+     * ```ts
+     * {
+     *    User: {
+     *      friends: mockedRelayStylePagination(store),
+     *      maleFriends: mockedRelayStylePagination(store, {
+     *        allNodesFn: (userRef) =>
+     *          store
+     *           .get(userRef, ['friends', 'edges'])
+     *           .map((e) => store.get(e, 'node'))
+     *           .filter((userRef) => store.get(userRef, 'sex') === 'male')
+     *      })
+     *    }
+     * }
+     * ```
+     */
+    allNodesFn?: AllNodesFn<TContext, TArgs>;
+    /**
+     * The function that'll be used to compute the cursor of a node.
+     *
+     * By default, it'll use `MockStore` internal reference `Ref`'s `key`
+     * as cursor.
+     */
+    cursorFn?: (nodeRef: Ref) => string;
+};
+export declare type RelayPaginationParams = {
+    first?: number;
+    after?: string;
+    last?: number;
+    before?: string;
+};
+export declare type RelayPageInfo = {
+    hasPreviousPage: boolean;
+    hasNextPage: boolean;
+    startCursor: string;
+    endCursor: string;
+};
+/**
+ * Produces a resolver that'll mock a [Relay-style cursor pagination](https://relay.dev/graphql/connections.htm).
+ *
+ * ```ts
+ * const schemaWithMocks = addMocksToSchema({
+ *   schema,
+ *   resolvers: (store) => ({
+ *     User: {
+ *       friends: relayStylePaginationMock(store),
+ *     }
+ *   }),
+ * })
+ * ```
+ * @param store the MockStore
+ */
+export declare const relayStylePaginationMock: <TContext, TArgs extends RelayPaginationParams = RelayPaginationParams>(store: IMockStore, { cursorFn, applyOnNodes, allNodesFn, }?: RelayStylePaginationMockOptions<TContext, TArgs>) => IFieldResolver<Ref<string>, TContext, TArgs, any>;

package/typings/pagination.d.ts

@@ -1,5 +1,5 @@
 import { IFieldResolver } from '@graphql-tools/utils';
-import { GraphQLResolveInfo } from '@graphql-tools/graphql';
+import { GraphQLResolveInfo } from 'graphql';
 import { IMockStore, Ref } from './types.js';
 export declare type AllNodesFn<TContext, TArgs extends RelayPaginationParams> = (parent: Ref, args: TArgs, context: TContext, info: GraphQLResolveInfo) => Ref[];
 export declare type RelayStylePaginationMockOptions<TContext, TArgs extends RelayPaginationParams> = {

package/typings/types.d.cts

@@ -0,0 +1,203 @@
+import { IResolvers } from '@graphql-tools/utils';
+import { ExecutionResult, GraphQLSchema } from 'graphql';
+export declare type IMockFn = () => unknown;
+export declare type IScalarMock = unknown | IMockFn;
+export declare type ITypeMock = () => {
+    [fieldName: string]: unknown | IMockFn;
+} | {
+    [fieldName: string]: IMockFn;
+};
+export declare 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;
+};
+export declare type KeyTypeConstraints = string | number;
+export declare type TypePolicy = {
+    /**
+     * The name of the field that should be used as store `key`.
+     *
+     * If `false`, no field will be used and `id` or `_id` will be used,
+     * otherwise we'll generate a random string
+     * as key.
+     */
+    keyFieldName?: string | false;
+};
+export declare type GetArgs<KeyT extends KeyTypeConstraints = string> = {
+    typeName: string;
+    key?: KeyT;
+    fieldName?: string;
+    /**
+     * Optional arguments when querying the field.
+     *
+     * Querying the field with the same arguments will return
+     * the same value. Deep equality is checked.
+     *
+     * ```ts
+     * store.get('User', 1, 'friend', { id: 2 }) === store.get('User', 1, 'friend', { id: 2 })
+     * store.get('User', 1, 'friend', { id: 2 }) !== store.get('User', 1, 'friend')
+     * ```
+     *
+     * Args can be a record, just like `args` argument of field resolver or an
+     * arbitrary string.
+     */
+    fieldArgs?: string | {
+        [argName: string]: any;
+    };
+    /**
+     * If no value found, insert the `defaultValue`.
+     */
+    defaultValue?: unknown | {
+        [fieldName: string]: any;
+    };
+};
+export declare type SetArgs<KeyT extends KeyTypeConstraints = string> = {
+    typeName: string;
+    key: KeyT;
+    fieldName?: string;
+    /**
+     * Optional arguments when querying the field.
+     *
+     * @see GetArgs#fieldArgs
+     */
+    fieldArgs?: string | {
+        [argName: string]: any;
+    };
+    value?: unknown | {
+        [fieldName: string]: any;
+    };
+    /**
+     * If the value for this field is already set, it won't
+     * be overridden.
+     *
+     * Propagates down do nested `set`.
+     */
+    noOverride?: boolean;
+};
+export interface IMockStore {
+    schema: GraphQLSchema;
+    /**
+     * Get a field value from the store for the given type, key and field
+     * name — and optionally field arguments. If the field name is not given,
+     * a reference to the type will be returned.
+     *
+     * If the the value for this field is not set, a value will be
+     * generated according to field return type and mock functions.
+     *
+     * If the field's output type is a `ObjectType` (or list of `ObjectType`),
+     * it will return a `Ref` (or array of `Ref`), ie a reference to an entity
+     * in the store.
+     *
+     * Example:
+     * ```ts
+     * store.get('Query', 'ROOT', 'viewer');
+     * > { $ref: { key: 'abc-737dh-djdjd', typeName: 'User' } }
+     * store.get('User', 'abc-737dh-djdjd', 'name')
+     * > "Hello World"
+     * ```
+     */
+    get<KeyT extends KeyTypeConstraints = string, ReturnKeyT extends KeyTypeConstraints = string>(args: GetArgs<KeyT>): unknown | Ref<ReturnKeyT>;
+    /**
+     * Shorthand for `get({typeName, key, fieldName, fieldArgs})`.
+     */
+    get<KeyT extends KeyTypeConstraints = string, ReturnKeyT extends KeyTypeConstraints = string>(typeName: string, key: KeyT, fieldNameOrFieldNames: string | string[], fieldArgs?: string | {
+        [argName: string]: any;
+    }): unknown | Ref<ReturnKeyT>;
+    /**
+     * Get a reference to the type.
+     */
+    get<KeyT extends KeyTypeConstraints = string>(typeName: string, keyOrDefaultValue?: KeyT | {
+        [fieldName: string]: any;
+    }, defaultValue?: {
+        [fieldName: string]: any;
+    }): unknown | Ref<KeyT>;
+    /**
+     * Shorthand for `get({typeName: ref.$ref.typeName, key: ref.$ref.key, fieldName, fieldArgs})`
+     * @param ref
+     * @param fieldNameOrFieldNames
+     * @param fieldArgs
+     */
+    get<KeyT extends KeyTypeConstraints = string, ReturnKeyT extends KeyTypeConstraints = string>(ref: Ref<KeyT>, fieldNameOrFieldNames: string | string[], fieldArgs?: string | {
+        [argName: string]: any;
+    }): unknown | Ref<ReturnKeyT>;
+    /**
+     * Set a field value in the store for the given type, key and field
+     * name — and optionally field arguments.
+     *
+     * If the the field return type is an `ObjectType` or a list of
+     * `ObjectType`, you can set references to other entity as value:
+     *
+     * ```ts
+     * // set the viewer name
+     * store.set('User', 1, 'name', 'Alexandre);
+     * store.set('Query', 'ROOT', 'viewer', store.get('User', 1));
+     *
+     * // set the friends of viewer
+     * store.set('User', 2, 'name', 'Emily');
+     * store.set('User', 3, 'name', 'Caroline');
+     * store.set('User', 1, 'friends', [store.get('User', 2), store.get('User', 3)]);
+     * ```
+     *
+     * But it also supports nested set:
+     *
+     * ```ts
+     * store.set('Query', 'ROOT', 'viewer', {
+     *  name: 'Alexandre',
+     *  friends: [
+     *    { name: 'Emily' }
+     *    { name: 'Caroline }
+     *  ]
+     * });
+     * ```
+     */
+    set<KeyT extends KeyTypeConstraints = string>(args: SetArgs<KeyT>): void;
+    /**
+     * Shorthand for `set({typeName, key, fieldName, value})`.
+     */
+    set<KeyT extends KeyTypeConstraints = string>(typeName: string, key: KeyT, fieldName: string, value?: unknown): void;
+    /**
+     * Set the given field values to the type with key.
+     */
+    set<KeyT extends KeyTypeConstraints = string>(typeName: string, key: KeyT, values: {
+        [fieldName: string]: any;
+    }): void;
+    /**
+     * Shorthand for `set({ref.$ref.typeName, ref.$ref.key, fieldName, value})`.
+     */
+    set<KeyT extends KeyTypeConstraints = string>(ref: Ref<KeyT>, fieldName: string, value?: unknown): void;
+    /**
+     * Set the given field values to the type with ref.
+     */
+    set<KeyT extends KeyTypeConstraints = string>(ref: Ref<KeyT>, values: {
+        [fieldName: string]: any;
+    }): void;
+    /**
+     * Checks if a mock is present in the store for the given typeName and key.
+     */
+    has<KeyT extends KeyTypeConstraints = string>(typeName: string, key: KeyT): boolean;
+    /**
+     * Resets the mock store
+     */
+    reset(): void;
+}
+export declare type Ref<KeyT extends KeyTypeConstraints = string> = {
+    $ref: {
+        key: KeyT;
+        typeName: string;
+    };
+};
+export declare function isRef<KeyT extends KeyTypeConstraints = string>(maybeRef: unknown): maybeRef is Ref<KeyT>;
+export declare function assertIsRef<KeyT extends KeyTypeConstraints = string>(maybeRef: unknown, message?: string): asserts maybeRef is Ref<KeyT>;
+export declare function isRecord(obj: unknown): obj is {
+    [key: string]: unknown;
+};
+export interface IMockServer {
+    /**
+     * Executes the provided query against the mocked schema.
+     * @param query GraphQL query to execute
+     * @param vars Variables
+     */
+    query: (query: string, vars?: Record<string, any>) => Promise<ExecutionResult>;
+}

package/typings/types.d.ts

@@ -1,5 +1,5 @@
 import { IResolvers } from '@graphql-tools/utils';
-import { ExecutionResult, GraphQLSchema } from '@graphql-tools/graphql';
+import { ExecutionResult, GraphQLSchema } from 'graphql';
 export declare type IMockFn = () => unknown;
 export declare type IScalarMock = unknown | IMockFn;
 export declare type ITypeMock = () => {

package/typings/utils.d.cts

@@ -0,0 +1,10 @@
+import { GraphQLObjectType, GraphQLSchema } from 'graphql';
+import { Ref, KeyTypeConstraints } from './types.cjs';
+export declare function uuidv4(): string;
+export declare const randomListLength: () => number;
+export declare const takeRandom: <T>(arr: T[]) => T;
+export declare function makeRef<KeyT extends KeyTypeConstraints = string>(typeName: string, key: KeyT): Ref<KeyT>;
+export declare function isObject(thing: any): boolean;
+export declare function copyOwnPropsIfNotPresent(target: Record<string, any>, source: Record<string, any>): void;
+export declare function copyOwnProps(target: Record<string, any>, ...sources: Array<Record<string, any>>): Record<string, any>;
+export declare const isRootType: (type: GraphQLObjectType, schema: GraphQLSchema) => boolean;

package/typings/utils.d.ts

@@ -1,4 +1,4 @@
-import { GraphQLObjectType, GraphQLSchema } from '@graphql-tools/graphql';
+import { GraphQLObjectType, GraphQLSchema } from 'graphql';
 import { Ref, KeyTypeConstraints } from './types.js';
 export declare function uuidv4(): string;
 export declare const randomListLength: () => number;