@graphql-tools/mock 8.6.13 → 8.7.0-alpha-b76ec274.0

package/cjs/addMocksToSchema.js

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addMocksToSchema = void 0;
+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");
+const utils_js_1 = require("./utils.js");
+const MockStore_js_1 = require("./MockStore.js");
+// todo: add option to preserve resolver
+/**
+ * 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'`.
+ */
+function addMocksToSchema({ schema, store: maybeStore, mocks, typePolicies, resolvers: resolversOrFnResolvers, preserveResolvers = false, }) {
+    if (!schema) {
+        throw new Error('Must provide schema to mock');
+    }
+    if (!(0, graphql_1.isSchema)(schema)) {
+        throw new Error('Value at "schema" must be of type GraphQLSchema');
+    }
+    if (mocks && !(0, utils_js_1.isObject)(mocks)) {
+        throw new Error('mocks must be of type Object');
+    }
+    const store = maybeStore ||
+        (0, MockStore_js_1.createMockStore)({
+            schema,
+            mocks,
+            typePolicies,
+        });
+    const resolvers = typeof resolversOrFnResolvers === 'function'
+        ? resolversOrFnResolvers(store)
+        : resolversOrFnResolvers;
+    const mockResolver = (source, args, contex, info) => {
+        const defaultResolvedValue = (0, graphql_1.defaultFieldResolver)(source, args, contex, info);
+        // priority to default resolved value
+        if (defaultResolvedValue !== undefined)
+            return defaultResolvedValue;
+        if ((0, types_js_1.isRef)(source)) {
+            return store.get({
+                typeName: source.$ref.typeName,
+                key: source.$ref.key,
+                fieldName: info.fieldName,
+                fieldArgs: args,
+            });
+        }
+        // we have to handle the root mutation, root query and root subscription types
+        // differently, because no resolver is called at the root
+        if ((0, utils_js_1.isRootType)(info.parentType, info.schema)) {
+            return store.get({
+                typeName: info.parentType.name,
+                key: 'ROOT',
+                fieldName: info.fieldName,
+                fieldArgs: args,
+            });
+        }
+        if (defaultResolvedValue === undefined) {
+            // any is used here because generateFieldValue is a private method at time of writing
+            return store.generateFieldValue(info.parentType.name, info.fieldName);
+        }
+        return undefined;
+    };
+    const typeResolver = data => {
+        if ((0, types_js_1.isRef)(data)) {
+            return data.$ref.typeName;
+        }
+    };
+    const mockSubscriber = () => ({
+        [Symbol.asyncIterator]() {
+            return {
+                async next() {
+                    return {
+                        done: true,
+                        value: {},
+                    };
+                },
+            };
+        },
+    });
+    const schemaWithMocks = (0, utils_1.mapSchema)(schema, {
+        [utils_1.MapperKind.OBJECT_FIELD]: fieldConfig => {
+            const newFieldConfig = {
+                ...fieldConfig,
+            };
+            const oldResolver = fieldConfig.resolve;
+            if (!preserveResolvers || !oldResolver) {
+                newFieldConfig.resolve = mockResolver;
+            }
+            else {
+                newFieldConfig.resolve = async (rootObject, args, context, info) => {
+                    const [mockedValue, resolvedValue] = await Promise.all([
+                        mockResolver(rootObject, args, context, info),
+                        oldResolver(rootObject, args, context, info),
+                    ]);
+                    // In case we couldn't mock
+                    if (mockedValue instanceof Error) {
+                        // only if value was not resolved, populate the error.
+                        if (undefined === resolvedValue) {
+                            throw mockedValue;
+                        }
+                        return resolvedValue;
+                    }
+                    if (resolvedValue instanceof Date && mockedValue instanceof Date) {
+                        return undefined !== resolvedValue ? resolvedValue : mockedValue;
+                    }
+                    if ((0, utils_js_1.isObject)(mockedValue) && (0, utils_js_1.isObject)(resolvedValue)) {
+                        // Object.assign() won't do here, as we need to all properties, including
+                        // the non-enumerable ones and defined using Object.defineProperty
+                        const emptyObject = Object.create(Object.getPrototypeOf(resolvedValue));
+                        return (0, utils_js_1.copyOwnProps)(emptyObject, resolvedValue, mockedValue);
+                    }
+                    return undefined !== resolvedValue ? resolvedValue : mockedValue;
+                };
+            }
+            const fieldSubscriber = fieldConfig.subscribe;
+            if (!preserveResolvers || !fieldSubscriber) {
+                newFieldConfig.subscribe = mockSubscriber;
+            }
+            else {
+                newFieldConfig.subscribe = async (rootObject, args, context, info) => {
+                    const [mockAsyncIterable, oldAsyncIterable] = await Promise.all([
+                        mockSubscriber(rootObject, args, context, info),
+                        fieldSubscriber(rootObject, args, context, info),
+                    ]);
+                    return oldAsyncIterable || mockAsyncIterable;
+                };
+            }
+            return newFieldConfig;
+        },
+        [utils_1.MapperKind.ABSTRACT_TYPE]: type => {
+            if (preserveResolvers && type.resolveType != null && type.resolveType.length) {
+                return;
+            }
+            if ((0, graphql_1.isUnionType)(type)) {
+                return new graphql_1.GraphQLUnionType({
+                    ...type.toConfig(),
+                    resolveType: typeResolver,
+                });
+            }
+            else {
+                return new graphql_1.GraphQLInterfaceType({
+                    ...type.toConfig(),
+                    resolveType: typeResolver,
+                });
+            }
+        },
+    });
+    return resolvers ? (0, schema_1.addResolversToSchema)(schemaWithMocks, resolvers) : schemaWithMocks;
+}
+exports.addMocksToSchema = addMocksToSchema;

package/cjs/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./MockStore.js"), exports);
+tslib_1.__exportStar(require("./addMocksToSchema.js"), exports);
+tslib_1.__exportStar(require("./mockServer.js"), exports);
+tslib_1.__exportStar(require("./types.js"), exports);
+tslib_1.__exportStar(require("./MockList.js"), exports);
+tslib_1.__exportStar(require("./pagination.js"), exports);

package/cjs/mockServer.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mockServer = void 0;
+const graphql_1 = require("graphql");
+const schema_1 = require("@graphql-tools/schema");
+const addMocksToSchema_js_1 = require("./addMocksToSchema.js");
+/**
+ * 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.
+ */
+function mockServer(schema, mocks, preserveResolvers = false) {
+    const mockedSchema = (0, addMocksToSchema_js_1.addMocksToSchema)({
+        schema: (0, graphql_1.isSchema)(schema)
+            ? schema
+            : (0, schema_1.makeExecutableSchema)({
+                typeDefs: schema,
+            }),
+        mocks,
+        preserveResolvers,
+    });
+    return {
+        query: (query, vars) => (0, graphql_1.graphql)({
+            schema: mockedSchema,
+            source: query,
+            rootValue: {},
+            contextValue: {},
+            variableValues: vars,
+        }),
+    };
+}
+exports.mockServer = mockServer;

package/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/cjs/pagination.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.relayStylePaginationMock = void 0;
+const utils_js_1 = require("./utils.js");
+/**
+ * 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
+ */
+const relayStylePaginationMock = (store, { cursorFn = node => `${node.$ref.key}`, applyOnNodes, allNodesFn, } = {}) => {
+    return (parent, args, context, info) => {
+        const source = (0, utils_js_1.isRootType)(info.parentType, info.schema) ? (0, utils_js_1.makeRef)(info.parentType.name, 'ROOT') : parent;
+        const allNodesFn_ = allNodesFn !== null && allNodesFn !== void 0 ? allNodesFn : defaultAllNodesFn(store);
+        let allNodes = allNodesFn_(source, args, context, info);
+        if (applyOnNodes) {
+            allNodes = applyOnNodes(allNodes, args);
+        }
+        const allEdges = allNodes.map(node => ({
+            node,
+            cursor: cursorFn(node),
+        }));
+        let start, end;
+        const { first, after, last, before } = args;
+        if (typeof first === 'number') {
+            // forward pagination
+            if (last || before) {
+                throw new Error("if `first` is provided, `last` or `before` can't be provided");
+            }
+            const afterIndex = after ? allEdges.findIndex(e => e.cursor === after) : -1;
+            start = afterIndex + 1;
+            end = afterIndex + 1 + first;
+        }
+        else if (typeof last === 'number') {
+            // backward pagination
+            if (first || after) {
+                throw new Error("if `last` is provided, `first` or `after` can't be provided");
+            }
+            const foundBeforeIndex = before ? allEdges.findIndex(e => e.cursor === before) : -1;
+            const beforeIndex = foundBeforeIndex !== -1 ? foundBeforeIndex : allNodes.length;
+            start = allEdges.length - (allEdges.length - beforeIndex) - last;
+            // negative index on Array.slice indicate offset from end of sequence => we don't want
+            if (start < 0)
+                start = 0;
+            end = beforeIndex;
+        }
+        else {
+            throw new Error('A `first` or a `last` arguments should be provided');
+        }
+        const edges = allEdges.slice(start, end);
+        const pageInfo = {
+            startCursor: edges.length > 0 ? edges[0].cursor : '',
+            endCursor: edges.length > 0 ? edges[edges.length - 1].cursor : '',
+            hasNextPage: end < allEdges.length - 1,
+            hasPreviousPage: start > 0,
+        };
+        return {
+            edges,
+            pageInfo,
+            totalCount: allEdges.length,
+        };
+    };
+};
+exports.relayStylePaginationMock = relayStylePaginationMock;
+const defaultAllNodesFn = (store) => (parent, _, __, info) => store.get(parent, [info.fieldName, 'edges']).map(e => store.get(e, 'node'));

package/cjs/types.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRecord = exports.assertIsRef = exports.isRef = void 0;
+function isRef(maybeRef) {
+    return !!(maybeRef && typeof maybeRef === 'object' && '$ref' in maybeRef);
+}
+exports.isRef = isRef;
+function assertIsRef(maybeRef, message) {
+    if (!isRef(maybeRef)) {
+        throw new Error(message || `Expected ${maybeRef} to be a valid Ref.`);
+    }
+}
+exports.assertIsRef = assertIsRef;
+function isRecord(obj) {
+    return typeof obj === 'object' && obj !== null;
+}
+exports.isRecord = isRecord;

package/cjs/utils.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRootType = exports.copyOwnProps = exports.copyOwnPropsIfNotPresent = exports.isObject = exports.makeRef = exports.takeRandom = exports.randomListLength = exports.uuidv4 = void 0;
+const utils_1 = require("@graphql-tools/utils");
+function uuidv4() {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {
+        const r = (Math.random() * 16) | 0;
+        // eslint-disable-next-line eqeqeq
+        const v = c == 'x' ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+}
+exports.uuidv4 = uuidv4;
+const randomListLength = () => {
+    // Mocking has always returned list of length 2 by default
+    // return 1 + Math.round(Math.random() * 10)
+    return 2;
+};
+exports.randomListLength = randomListLength;
+const takeRandom = (arr) => arr[Math.floor(Math.random() * arr.length)];
+exports.takeRandom = takeRandom;
+function makeRef(typeName, key) {
+    return { $ref: { key, typeName } };
+}
+exports.makeRef = makeRef;
+function isObject(thing) {
+    return thing === Object(thing) && !Array.isArray(thing);
+}
+exports.isObject = isObject;
+function copyOwnPropsIfNotPresent(target, source) {
+    for (const prop of Object.getOwnPropertyNames(source)) {
+        if (!Object.getOwnPropertyDescriptor(target, prop)) {
+            const propertyDescriptor = Object.getOwnPropertyDescriptor(source, prop);
+            Object.defineProperty(target, prop, propertyDescriptor == null ? {} : propertyDescriptor);
+        }
+    }
+}
+exports.copyOwnPropsIfNotPresent = copyOwnPropsIfNotPresent;
+function copyOwnProps(target, ...sources) {
+    for (const source of sources) {
+        let chain = source;
+        while (chain != null) {
+            copyOwnPropsIfNotPresent(target, chain);
+            chain = Object.getPrototypeOf(chain);
+        }
+    }
+    return target;
+}
+exports.copyOwnProps = copyOwnProps;
+const isRootType = (type, schema) => {
+    const rootTypeNames = (0, utils_1.getRootTypeNames)(schema);
+    return rootTypeNames.has(type.name);
+};
+exports.isRootType = isRootType;

package/esm/MockList.js

@@ -0,0 +1,69 @@
+/**
+ * @internal
+ */
+export function isMockList(obj) {
+    if (typeof (obj === null || obj === void 0 ? void 0 : obj.len) === 'number' || (Array.isArray(obj === null || obj === void 0 ? void 0 : obj.len) && typeof (obj === null || obj === void 0 ? void 0 : obj.len[0]) === 'number')) {
+        if (typeof obj.wrappedFunction === 'undefined' || typeof obj.wrappedFunction === 'function') {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * This is an object you can return from your mock resolvers which calls the
+ * provided `mockFunction` once for each list item.
+ */
+export class MockList {
+    /**
+     * @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, mockFunction) {
+        this.len = length;
+        if (typeof mockFunction !== 'undefined') {
+            if (typeof mockFunction !== 'function') {
+                throw new Error('Second argument to MockList must be a function or undefined');
+            }
+            this.wrappedFunction = mockFunction;
+        }
+    }
+    /**
+     * @internal
+     */
+    mock() {
+        let arr;
+        if (Array.isArray(this.len)) {
+            arr = new Array(this.randint(this.len[0], this.len[1]));
+        }
+        else {
+            arr = new Array(this.len);
+        }
+        for (let i = 0; i < arr.length; i++) {
+            if (typeof this.wrappedFunction === 'function') {
+                const res = this.wrappedFunction();
+                if (isMockList(res)) {
+                    arr[i] = res.mock();
+                }
+                else {
+                    arr[i] = res;
+                }
+            }
+            else {
+                arr[i] = undefined;
+            }
+        }
+        return arr;
+    }
+    randint(low, high) {
+        return Math.floor(Math.random() * (high - low + 1) + low);
+    }
+}
+export function deepResolveMockList(mockList) {
+    return mockList.mock().map(v => {
+        if (isMockList(v))
+            return deepResolveMockList(v);
+        return v;
+    });
+}