graphql-data-generator 0.3.0-alpha.1 → 0.3.0-alpha.11

package/esm/cli.js

@@ -6,97 +6,99 @@ import { parseArgs } from "node:util";
 import { codegen, loadFiles } from "./codegen.js";
 import { formatCode } from "./util.js";
 import process from "node:process";
-const args = parseArgs({
-    args: process.argv.slice(2),
-    options: {
-        banner: { type: "string" },
-        enums: { type: "string" },
-        exports: { type: "string", multiple: true },
-        namingConvention: { type: "string" },
-        notypenames: { type: "boolean" },
-        operations: { type: "string", multiple: true },
-        outfile: { type: "string" },
-        scalar: { type: "string", multiple: true },
-        scalars: { type: "string" },
-        schema: { type: "string" },
-        typesFile: { type: "string" },
-    },
-}).values;
-const findFirst = async (path) => {
-    for await (const file of fg.stream(path)) {
-        return file.toString();
+(async () => {
+    const args = parseArgs({
+        args: process.argv.slice(2),
+        options: {
+            banner: { type: "string" },
+            enums: { type: "string" },
+            exports: { type: "string", multiple: true },
+            namingConvention: { type: "string" },
+            notypenames: { type: "boolean" },
+            operations: { type: "string", multiple: true },
+            outfile: { type: "string" },
+            scalar: { type: "string", multiple: true },
+            scalars: { type: "string" },
+            schema: { type: "string" },
+            typesFile: { type: "string" },
+        },
+    }).values;
+    const findFirst = async (path) => {
+        for await (const file of fg.stream(path)) {
+            return file.toString();
+        }
+    };
+    const schemaPath = args.schema
+        ? await findFirst(args.schema)
+        : (await findFirst("**/schema.graphql") ??
+            await findFirst("**/schema.gql") ??
+            await findFirst("**/schema.graphqls"));
+    const fail = (reason, code = 1) => {
+        process.stderr.write(reason + "\n");
+        process.exit(code);
+    };
+    if (!schemaPath) {
+        fail(`Could not locate schema${args.schema ? ` "${args.schema}"` : ", try passing --schema"}`);
+        throw ""; // TS being dumb?
+    }
+    const operationDirs = args.operations?.map((v) => `${v}`) ?? ["."];
+    const [schema, operations] = await loadFiles(schemaPath, operationDirs);
+    const scalars = {};
+    if (args.scalars) {
+        readFile;
+        Object.assign(scalars, JSON.parse(await dntShim.Deno.readTextFile(args.scalars)));
     }
-};
-const schemaPath = args.schema
-    ? await findFirst(args.schema)
-    : (await findFirst("**/schema.graphql") ??
-        await findFirst("**/schema.gql") ??
-        await findFirst("**/schema.graphqls"));
-const fail = (reason, code = 1) => {
-    process.stderr.write(reason + "\n");
-    process.exit(code);
-};
-if (!schemaPath) {
-    fail(`Could not locate schema${args.schema ? ` "${args.schema}"` : ", try passing --schema"}`);
-    throw ""; // TS being dumb?
-}
-const operationDirs = args.operations?.map((v) => `${v}`) ?? ["."];
-const [schema, operations] = await loadFiles(schemaPath, operationDirs);
-const scalars = {};
-if (args.scalars) {
-    readFile;
-    Object.assign(scalars, JSON.parse(await dntShim.Deno.readTextFile(args.scalars)));
-}
-if (args.scalar) {
-    for (const kv of args.scalar) {
-        const [key, value] = `${kv}`.split(":");
-        if (!value) {
-            fail("Invalid --scalar argument. Pass as a key-value pair like --scalar=key:value");
+    if (args.scalar) {
+        for (const kv of args.scalar) {
+            const [key, value] = `${kv}`.split(":");
+            if (!value) {
+                fail("Invalid --scalar argument. Pass as a key-value pair like --scalar=key:value");
+            }
+            scalars[key] = value;
         }
-        scalars[key] = value;
     }
-}
-const validExports = ["operations", "types"];
-const exports = args.exports
-    ? args.exports.filter((e) => {
-        if (!validExports.includes(e)) {
-            throw new Error(`Invalid export. Must be ${validExports.join(", ")}`);
+    const validExports = ["operations", "types"];
+    const exports = args.exports
+        ? args.exports.filter((e) => {
+            if (!validExports.includes(e)) {
+                throw new Error(`Invalid export. Must be ${validExports.join(", ")}`);
+            }
+            return true;
+        })
+        : [];
+    if (typeof args.enums === "string" &&
+        (!["enums", "literals", "none"].includes(args.enums) &&
+            !args.enums.startsWith("import:"))) {
+        throw new Error(`Invalid 'enums'. Must be one of 'enums', 'literals', 'import', 'none'`);
+    }
+    let banner = "";
+    if (typeof args.banner === "string") {
+        if (await dntShim.Deno.lstat(args.banner).catch(() => false)) {
+            banner = await dntShim.Deno.readTextFile(args.banner);
         }
-        return true;
-    })
-    : [];
-if (typeof args.enums === "string" &&
-    (!["enums", "literals", "none"].includes(args.enums) &&
-        !args.enums.startsWith("import:"))) {
-    throw new Error(`Invalid 'enums'. Must be one of 'enums', 'literals', 'import', 'none'`);
-}
-let banner = "";
-if (typeof args.banner === "string") {
-    if (await dntShim.Deno.lstat(args.banner).catch(() => false)) {
-        banner = await dntShim.Deno.readTextFile(args.banner);
+        else
+            banner = args.banner;
     }
-    else
-        banner = args.banner;
-}
-try {
-    const file = banner + await formatCode(codegen(schema, operations, {
-        enums: args.enums,
-        includeTypenames: !args.notypenames,
-        scalars,
-        exports,
-        typesFile: args.typesFile,
-        namingConvention: args.namingConvention,
-    }));
-    if (args.outfile)
-        await dntShim.Deno.writeTextFile(args.outfile, file);
-    else
-        console.log(file);
-}
-catch (err) {
-    const message = err instanceof Error ? err.message : `${err}`;
-    if (message.startsWith("Could not find scalar")) {
-        const scalar = message.match(/'([^']*)'/)?.[1];
-        fail(`${message}. Try passing --scalars=scalars.json or --scalar=${scalar ?? "scalar"}:string, replacing string with the TypeScript type of the scalar.`);
+    try {
+        const file = banner + await formatCode(codegen(schema, operations, {
+            enums: args.enums,
+            includeTypenames: !args.notypenames,
+            scalars,
+            exports,
+            typesFile: args.typesFile,
+            namingConvention: args.namingConvention,
+        }));
+        if (args.outfile)
+            await dntShim.Deno.writeTextFile(args.outfile, file);
+        else
+            console.log(file);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : `${err}`;
+        if (message.startsWith("Could not find scalar")) {
+            const scalar = message.match(/'([^']*)'/)?.[1];
+            fail(`${message}. Try passing --scalars=scalars.json or --scalar=${scalar ?? "scalar"}:string, replacing string with the TypeScript type of the scalar.`);
+        }
+        fail(err instanceof Error ? err.message : err);
     }
-    fail(err instanceof Error ? err.message : err);
-}
+})();

package/esm/init.js

@@ -1,11 +1,16 @@
+import * as dntShim from "./_dnt.shims.js";
+import { createRequire } from "node:module";
 import { readFileSync } from "node:fs";
 import { Kind, parse } from "graphql";
-import { dirname, join } from "node:path";
 import { gqlPluckFromCodeStringSync } from "@graphql-tools/graphql-tag-pluck";
 import { operation, proxy, withGetDefaultPatch } from "./proxy.js";
 import { toObject } from "./util.js";
+import { dirname } from "node:path";
+globalThis.require ??= createRequire(dntShim.Deno.cwd());
 const files = {};
-const loadFile = (path) => files[path] || (files[path] = readFileSync(path, "utf-8").replace(/#import "(.*)"/, (_, fragmentPath) => loadFile(join(dirname(path), fragmentPath))));
+const loadFile = (path) => files[path] || (files[path] = readFileSync(path, "utf-8").replace(/#import "(.*)"/, (_, fragmentPath) => loadFile(require.resolve(fragmentPath, {
+    paths: [dirname(path), dntShim.Deno.cwd()],
+}))));
 const getOperationContentMap = {};
 const getOperationContent = (path, operationName) => {
     const existing = getOperationContentMap[path];
@@ -14,7 +19,7 @@ const getOperationContent = (path, operationName) => {
             return existing;
         return getOperationContentMap[path][operationName];
     }
-    const fileContent = readFileSync(path, "utf-8").replace(/#import "(.*)"/, (_, fragmentPath) => loadFile(join(dirname(path), fragmentPath)));
+    const fileContent = loadFile(path);
     try {
         const sources = gqlPluckFromCodeStringSync(path, fileContent);
         getOperationContentMap[path] = Object.fromEntries(sources.map((s) => {
@@ -104,7 +109,6 @@ export const init = (schema, queries, mutations, subscriptions, types, inputs, s
                             : variables,
                     });
                     Error.captureStackTrace(mock, obj.variables);
-                    mock.stack = mock.stack?.slice(6);
                     return mock;
                 },
             },
@@ -125,7 +129,6 @@ export const init = (schema, queries, mutations, subscriptions, types, inputs, s
                             : data,
                     });
                     Error.captureStackTrace(mock, obj.data);
-                    mock.stack = mock.stack?.slice(6);
                     return mock;
                 },
             },
@@ -146,7 +149,6 @@ export const init = (schema, queries, mutations, subscriptions, types, inputs, s
                     const builder = build[operation];
                     const mock = builder(prevInput, patch);
                     Error.captureStackTrace(mock, obj[name]);
-                    mock.stack = mock.stack?.slice(6);
                     return mock;
                 },
             }])));
@@ -165,7 +167,6 @@ export const init = (schema, queries, mutations, subscriptions, types, inputs, s
             });
             mock.request.query = parsedQuery;
             Error.captureStackTrace(mock, builder);
-            mock.stack = mock.stack?.slice(6);
             return addOperationTransforms(name, options?.finalizeOperation
                 ? options.finalizeOperation(mock)
                 : mock);

package/esm/jest.js

@@ -1,11 +1,10 @@
 import * as dntShim from "./_dnt.shims.js";
-import "./deps/esm.sh/@types/jest@29.5.3/index";
 import React, { useMemo } from "react";
-import { ApolloLink } from "@apollo/client";
-import { ErrorLink } from "@apollo/client/link/error/index.js";
-import { MockedProvider, MockLink, } from "@apollo/client/testing/index.js";
+import { ApolloLink, useApolloClient, } from "@apollo/client";
+import { onError } from "@apollo/client/link/error";
+import { MockedProvider, MockLink, } from "@apollo/client/testing";
 import { waitFor } from "@testing-library/dom";
-import { print } from "graphql";
+import { Kind, print } from "graphql";
 import { diff as jestDiff } from "jest-diff";
 let currentSpecResult;
 jasmine.getEnv().addReporter({
@@ -13,25 +12,26 @@ jasmine.getEnv().addReporter({
 });
 const afterTest = [];
 afterEach(async () => {
-    for (const hook of afterTest)
+    const hooks = afterTest.splice(0);
+    for (const hook of hooks)
         await hook();
-    afterTest.splice(0);
 });
-const diff = (a, b) => jestDiff(a, b, {
-    omitAnnotationLines: true,
-    // aColor: green,
-    // bColor: red,
-    // changeColor: inverse,
-    // commonColor: dim,
-    // patchColor: yellow,
-})
+const diff = (a, b) => jestDiff(a, b, { omitAnnotationLines: true })
     ?.replace(/\w+ \{/g, "{") // Remove class names
     .replace(/\w+ \[/g, "["); // Remove array class names
+const getOperationDefinition = (document) => document.definitions.find((d) => d.kind === Kind.OPERATION_DEFINITION);
+const getOperationType = (operation) => getOperationDefinition(operation.query)?.operation ??
+    "<unknown operation type>";
+const getOperationName = (document) => getOperationDefinition(document)?.name?.value;
+const getOperationInfo = (document) => {
+    const def = getOperationDefinition(document);
+    return {
+        name: def?.name?.value ?? "<unknown operation>",
+        operationType: def?.operation ?? "<unknown operation type>",
+    };
+};
 const getErrorMessage = (operation, mockLink) => {
-    const definition = operation.query.definitions[0];
-    const operationType = definition.kind === "OperationDefinition"
-        ? definition.operation
-        : "<unknown operation type>";
+    const operationType = getOperationType(operation);
     const key = JSON.stringify({
         query: print(operation.query),
     });
@@ -39,7 +39,7 @@ const getErrorMessage = (operation, mockLink) => {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const alts = (mockLink
         .mockedResponsesByKey[key] ?? []);
-    let errorMessage = `Expected GraphQL ${operationType} ${operation.operationName} to have been mocked`;
+    let errorMessage = `Expected ${operationType} ${operation.operationName} to have been mocked`;
     if (alts.length || Object.keys(operation.variables).length > 0) {
         errorMessage += ` with variables ${dntShim.Deno.inspect(operation.variables, { depth: Infinity, colors: true })}`;
     }
@@ -62,59 +62,154 @@ const getErrorMessage = (operation, mockLink) => {
             : undefined,
     };
 };
-export const MockProvider = ({ mocks, stack, children }) => {
+let _failRefetchWarnings = false;
+/**
+ * In older versions of `@apollo/client`, refetches with missing mocks trigger
+ * warnings instead of being treated as standard missing mocks.
+ * This utility converts those warnings into failures and ensures watch queries
+ * are installed for queries with `watch: true`. This must be set when
+ * `MockProvider` is mounted.
+ *
+ * This is not required on modern version of `@apollo/client`.
+ */
+export const failRefetchWarnings = (value = true) => _failRefetchWarnings = value;
+let _allowMissingMocks = false;
+/**
+ * Allows missing mocks, resulting in tests passing. Usage is intended to ease
+ * migration.
+ */
+export const allowMissingMocks = (value) => _allowMissingMocks = value;
+const AutoWatch = ({ mocks }) => {
+    const client = useApolloClient();
+    for (const mock of mocks)
+        if (mock.watch)
+            client.watchQuery(mock.request);
+    return null;
+};
+let lastMocks = [];
+// deno-lint-ignore ban-types
+const getStack = (to) => {
+    const obj = {};
+    Error.captureStackTrace(obj, to);
+    return obj.stack;
+};
+const _waitForMocks = async (mocks, cause) => {
+    for (const mock of mocks) {
+        if (mock.optional || mock.error)
+            continue;
+        await waitFor(() => {
+            if (currentSpecResult.failedExpectations.length)
+                return;
+            if (mock.result.mock.calls.length === 0) {
+                const { name, operationType } = getOperationInfo(mock.request.query);
+                const err = new Error(`Expected to have used ${operationType} ${name}${mock.request.variables
+                    ? ` with variables ${dntShim.Deno.inspect(mock.request.variables, {
+                        depth: Infinity,
+                        colors: true,
+                    })}`
+                    : ""}`);
+                err.stack = `${mock.stack}${cause ? `\nCaused by: ${cause}` : ""}`;
+                throw err;
+            }
+        });
+    }
+};
+/**
+ * Wait for mocks to have been used.
+ * @param mock If `undefined`, waits for all mocks. If a number, waits fort he first `mocks` mocks. If a string, waits for all mocks up until and including that mock.
+ * @param offset If `mocks` is a string, grabs the `offset`th mock of that name (e.g., the third `getReport` mock)
+ */
+export const waitForMocks = async (mock = lastMocks.length, offset = 0) => {
+    if (typeof mock === "string") {
+        const matches = lastMocks.map((m, i) => [m, i])
+            .filter(([m]) => getOperationName(m.request.query) === mock);
+        if (matches.length <= offset) {
+            fail({
+                name: "Error",
+                message: `Expected mock ${mock} to have been mocked`,
+                stack: getStack(waitForMocks),
+            });
+        }
+        expect(matches.length).toBeGreaterThan(offset);
+        mock = matches[offset][1] + 1;
+    }
+    await _waitForMocks(lastMocks.slice(0, mock), getStack(waitForMocks));
+};
+/**
+ * A wrapper for `@apollo/client/testing`, this component will assert all
+ * requests have matching mocks and all defined mocks are used unless marked
+ * `optional`.
+ */
+export const MockProvider = ({ mocks, stack: renderStack, children, link: passedLink, ...rest }) => {
     const observableMocks = useMemo(() => {
         const observableMocks = mocks.map((m) => ({
             ...m,
             stack: m.stack,
             result: Object.assign(jest.fn(() => m.result), m.result),
         }));
-        afterTest.push(async () => {
-            if (currentSpecResult.failedExpectations.length)
-                return;
-            for (const mock of observableMocks) {
-                if ("optional" in mock && mock.optional || mock.error)
-                    continue;
-                await waitFor(() => {
-                    if (currentSpecResult.failedExpectations.length)
-                        return;
-                    if (mock.result.mock.calls.length === 0) {
-                        const err = new Error(`Expected to have used mock ${mock.request.variables
-                            ? ` with variables ${dntShim.Deno.inspect(mock.request.variables, {
-                                depth: Infinity,
-                                colors: true,
-                            })}`
-                            : ""}`);
-                        err.stack = `${err.message}\n${mock.stack ?? stack ?? err.stack?.slice(6)}`;
-                        throw err;
-                    }
-                }, { onTimeout: (e) => e });
-            }
-        });
-        return observableMocks;
+        lastMocks = observableMocks;
+        afterTest.push(() => _waitForMocks(lastMocks, renderStack));
+        return observableMocks.flatMap((m) => [
+            m,
+            ...(m.watch
+                ? [{
+                        ...m,
+                        stack: m.stack,
+                        result: Object.assign(jest.fn(() => m.result), m.result),
+                        watch: false,
+                    }]
+                : []),
+        ]);
     }, [mocks]);
     const link = useMemo(() => {
         const mockLink = new MockLink(observableMocks);
         mockLink.showWarnings = false;
-        const errorLoggingLink = new ErrorLink(({ networkError, operation }) => {
-            if (!networkError?.message.includes("No more mocked responses"))
+        const errorLoggingLink = onError(({ networkError, operation }) => {
+            if (_allowMissingMocks ||
+                !networkError?.message.includes("No more mocked responses"))
                 return;
             const { message, stack: altStack } = getErrorMessage(operation, mockLink);
             try {
                 networkError.message = message;
-                const finalStack = altStack ?? stack
-                    ? `${message}\n${altStack ?? stack}`
-                    : undefined;
-                if (finalStack)
-                    networkError.stack = finalStack;
-                fail({ name: "Error", message, stack: finalStack });
+                const stack = altStack ?? renderStack;
+                if (stack)
+                    networkError.stack = stack;
+                fail({ name: "Error", message, stack: networkError.stack });
             }
             catch {
                 // fail both throws and marks the test as failed in jest; we only need the latter
             }
         });
-        // @ts-ignore It's fine
-        return ApolloLink.from([errorLoggingLink, mockLink]);
-    }, [observableMocks, stack]);
-    return React.createElement(MockedProvider, { link: link }, children);
+        return ApolloLink.from([
+            errorLoggingLink,
+            mockLink,
+            ...(passedLink ? [passedLink] : []),
+        ]);
+    }, [observableMocks, renderStack]);
+    if (_failRefetchWarnings) {
+        const oldWarn = console.warn.bind(console.warn);
+        console.warn = (message, operation, ...etc) => {
+            if (message !==
+                'Unknown query named "%s" requested in refetchQueries in options.include array') {
+                return oldWarn(message, operation, ...etc);
+            }
+            try {
+                fail({
+                    name: "Error",
+                    message: `Expected query ${operation} requested in refetchQueries options.include array to have bene mocked`,
+                    stack: renderStack,
+                });
+            }
+            catch {
+                // eat
+            }
+        };
+        afterTest.push(() => {
+            console.warn = oldWarn;
+        });
+    }
+    return (React.createElement(MockedProvider, { ...rest, link: link },
+        React.createElement(React.Fragment, null,
+            React.createElement(AutoWatch, { mocks: observableMocks }),
+            children)));
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphql-data-generator",
-  "version": "0.3.0-alpha.1",
+  "version": "0.3.0-alpha.11",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/voces/graphql-data-generator.git"
@@ -9,7 +9,7 @@
   "bugs": {
     "url": "https://github.com/voces/graphql-data-generator/issues"
   },
-  "main": "./esm/index.js",
+  "main": "./script/index.js",
   "module": "./esm/index.js",
   "types": "./types/index.d.ts",
   "exports": {
@@ -35,6 +35,16 @@
   "bin": {
     "graphql-data-generator": "./esm/cli.js"
   },
+  "typesVersions": {
+    "*": {
+      "script/jest": [
+        "types/jest.d.ts"
+      ],
+      "script/plugin": [
+        "types/plugin.d.ts"
+      ]
+    }
+  },
   "dependencies": {
     "@graphql-codegen/visitor-plugin-common": "*",
     "fast-glob": "*",

package/script/_dnt.shims.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dntGlobalThis = exports.Deno = void 0;
+const shim_deno_1 = require("@deno/shim-deno");
+var shim_deno_2 = require("@deno/shim-deno");
+Object.defineProperty(exports, "Deno", { enumerable: true, get: function () { return shim_deno_2.Deno; } });
+const dntGlobals = {
+    Deno: shim_deno_1.Deno,
+};
+exports.dntGlobalThis = createMergeProxy(globalThis, dntGlobals);
+function createMergeProxy(baseObj, extObj) {
+    return new Proxy(baseObj, {
+        get(_target, prop, _receiver) {
+            if (prop in extObj) {
+                return extObj[prop];
+            }
+            else {
+                return baseObj[prop];
+            }
+        },
+        set(_target, prop, value) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            baseObj[prop] = value;
+            return true;
+        },
+        deleteProperty(_target, prop) {
+            let success = false;
+            if (prop in extObj) {
+                delete extObj[prop];
+                success = true;
+            }
+            if (prop in baseObj) {
+                delete baseObj[prop];
+                success = true;
+            }
+            return success;
+        },
+        ownKeys(_target) {
+            const baseKeys = Reflect.ownKeys(baseObj);
+            const extKeys = Reflect.ownKeys(extObj);
+            const extKeysSet = new Set(extKeys);
+            return [...baseKeys.filter((k) => !extKeysSet.has(k)), ...extKeys];
+        },
+        defineProperty(_target, prop, desc) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            Reflect.defineProperty(baseObj, prop, desc);
+            return true;
+        },
+        getOwnPropertyDescriptor(_target, prop) {
+            if (prop in extObj) {
+                return Reflect.getOwnPropertyDescriptor(extObj, prop);
+            }
+            else {
+                return Reflect.getOwnPropertyDescriptor(baseObj, prop);
+            }
+        },
+        has(_target, prop) {
+            return prop in extObj || prop in baseObj;
+        },
+    });
+}