@graphql-tools/mock 8.3.2-alpha-5d885fa3.0 → 8.4.0

package/MockStore.d.ts

@@ -22,6 +22,7 @@ export declare class MockStore implements IMockStore {
             [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[] | {

package/index.js

@@ -145,6 +145,9 @@ class MockStore {
         this.mocks = { ...defaultMocks, ...mocks };
         this.typePolicies = typePolicies || {};
     }
+    has(typeName, key) {
+        return !!this.store[typeName] && !!this.store[typeName][key];
+    }
     get(_typeName, _key, _fieldName, _fieldArgs) {
         if (typeof _typeName !== 'string') {
             if (_key === undefined) {

package/index.mjs

@@ -139,6 +139,9 @@ class MockStore {
         this.mocks = { ...defaultMocks, ...mocks };
         this.typePolicies = typePolicies || {};
     }
+    has(typeName, key) {
+        return !!this.store[typeName] && !!this.store[typeName][key];
+    }
     get(_typeName, _key, _fieldName, _fieldArgs) {
         if (typeof _typeName !== 'string') {
             if (_key === undefined) {

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@graphql-tools/mock",
-  "version": "8.3.2-alpha-5d885fa3.0",
+  "version": "8.4.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"
   },
   "dependencies": {
-    "@graphql-tools/schema": "8.2.1-alpha-5d885fa3.0",
-    "@graphql-tools/utils": "^8.2.0",
+    "@graphql-tools/schema": "^8.2.0",
+    "@graphql-tools/utils": "^8.2.3",
     "fast-json-stable-stringify": "^2.1.0",
     "tslib": "~2.3.0"
   },

package/types.d.ts

@@ -168,6 +168,10 @@ export interface IMockStore {
     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
      */

package/es5/MockList.d.ts

@@ -1,25 +0,0 @@
-/**
- * @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/es5/MockStore.d.ts

@@ -1,93 +0,0 @@
-import { GraphQLSchema } from 'graphql';
-import { IMockStore, GetArgs, SetArgs, Ref, TypePolicy, IMocks, KeyTypeConstraints } from './types';
-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;
-        };
-    });
-    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/es5/README.md

@@ -1,5 +0,0 @@
-Check API Reference for more information about this package;
-https://www.graphql-tools.com/docs/api/modules/mock
-
-You can also learn more about Mocking in this chapter;
-https://www.graphql-tools.com/docs/mocking

package/es5/addMocksToSchema.d.ts

@@ -1,78 +0,0 @@
-import { GraphQLSchema } from 'graphql';
-import { IResolvers } from '@graphql-tools/utils';
-import { IMockStore, IMocks, TypePolicy } from './types';
-declare type IMockOptions = {
-    schema: GraphQLSchema;
-    store?: IMockStore;
-    mocks?: IMocks;
-    typePolicies?: {
-        [typeName: string]: TypePolicy;
-    };
-    resolvers?: IResolvers | ((store: IMockStore) => IResolvers);
-    /**
-     * 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({ schema, store: maybeStore, mocks, typePolicies, resolvers: resolversOrFnResolvers, preserveResolvers, }: IMockOptions): GraphQLSchema;
-export {};

package/es5/index.d.ts

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