graphql-data-generator 0.2.3 → 0.3.0-alpha.0

package/esm/codegen.js

@@ -555,7 +555,9 @@ ${usedTypes.map(([name]) => `  ${name}: ${rename(name)};`).join("\n")}
     }
     else if (enums.startsWith("import:") &&
         usedReferences.some((r) => r.kind === Kind.ENUM_TYPE_DEFINITION)) {
-        serializedTypes.unshift(`import { ${usedReferences.filter((r) => r.kind === Kind.ENUM_TYPE_DEFINITION).map((r) => r.name.value).join(", ")} } from "${enums.slice(7)}";`);
+        serializedTypes.unshift(`import {
+  ${usedReferences.filter((r) => r.kind === Kind.ENUM_TYPE_DEFINITION).map((r) => r.name.value).join(",\n  ")},
+} from "${enums.slice(7)}";`);
     }
     return serializedTypes.join("\n\n") + "\n";
 };

package/esm/init.js

@@ -72,18 +72,62 @@ export const init = (schema, queries, mutations, subscriptions, types, inputs, s
         return `${kind}${operation[0].toUpperCase()}${operation.slice(1)}`;
     };
     const addOperationTransforms = (operation, obj) => {
-        Object.defineProperty(obj, "patch", {
-            value: (...patches) => {
-                const prev = typeof obj === "function" ? obj() : obj;
-                const builder = build[operation];
-                const { result, request, error, ...rest } = prev;
-                return builder({
-                    data: result.data,
-                    variables: request.variables,
-                    error: error,
-                    errors: result.errors,
-                    ...rest,
-                }, ...patches);
+        Object.defineProperties(obj, {
+            patch: {
+                value: (...patches) => {
+                    const prev = typeof obj === "function" ? obj() : obj;
+                    const builder = build[operation];
+                    const { result, request, error, ...rest } = prev;
+                    return builder({
+                        data: result.data,
+                        variables: request.variables,
+                        error: error,
+                        errors: result.errors,
+                        ...rest,
+                    }, ...patches);
+                },
+            },
+            variables: {
+                value: (variables) => {
+                    const prev = typeof obj === "function" ? obj() : obj;
+                    const builder = build[operation];
+                    const { result, request, error, ...rest } = prev;
+                    const mock = builder({
+                        data: result.data,
+                        variables: request.variables,
+                        error: error,
+                        errors: result.errors,
+                        ...rest,
+                    }, {
+                        variables: typeof variables === "function"
+                            ? variables(result.data, request.variables)
+                            : variables,
+                    });
+                    Error.captureStackTrace(mock, obj.variables);
+                    mock.stack = mock.stack?.slice(6);
+                    return mock;
+                },
+            },
+            data: {
+                value: (data) => {
+                    const prev = typeof obj === "function" ? obj() : obj;
+                    const builder = build[operation];
+                    const { result, request, error, ...rest } = prev;
+                    const mock = builder({
+                        data: result.data,
+                        variables: request.variables,
+                        error: error,
+                        errors: result.errors,
+                        ...rest,
+                    }, {
+                        data: typeof data === "function"
+                            ? data(request.variables, result.data)
+                            : data,
+                    });
+                    Error.captureStackTrace(mock, obj.data);
+                    mock.stack = mock.stack?.slice(6);
+                    return mock;
+                },
             },
         });
         Object.defineProperties(obj, Object.fromEntries(Object.entries(transforms[operation] ?? {}).map(([name, fn]) => [name, {
@@ -100,26 +144,34 @@ export const init = (schema, queries, mutations, subscriptions, types, inputs, s
                         ? operationFn(prevInput, ...args)
                         : operationFn);
                     const builder = build[operation];
-                    return builder(prevInput, patch);
+                    const mock = builder(prevInput, patch);
+                    Error.captureStackTrace(mock, obj[name]);
+                    mock.stack = mock.stack?.slice(6);
+                    return mock;
                 },
             }])));
         return obj;
     };
-    const operationBuilder = (name, path) => addOperationTransforms(name, (...patches) => {
-        const query = getOperationContent(path, name);
-        if (transforms[name] && "default" in transforms[name]) {
-            patches = [transforms[name].default, ...patches];
-        }
-        const { request: { query: parsedQuery, ...request }, ...raw } = operation(doc.definitions, scalars, query, ...patches);
-        const result = toObject({
-            request: { ...request },
-            ...raw,
-        });
-        result.request.query = parsedQuery;
-        return addOperationTransforms(name, options?.finalizeOperation
-            ? options.finalizeOperation(result)
-            : result);
-    });
+    const operationBuilder = (name, path) => {
+        const builder = (...patches) => {
+            const query = getOperationContent(path, name);
+            if (transforms[name] && "default" in transforms[name]) {
+                patches = [transforms[name].default, ...patches];
+            }
+            const { request: { query: parsedQuery, ...request }, ...raw } = operation(doc.definitions, scalars, query, ...patches);
+            const mock = toObject({
+                request: { ...request },
+                ...raw,
+            });
+            mock.request.query = parsedQuery;
+            Error.captureStackTrace(mock, builder);
+            mock.stack = mock.stack?.slice(6);
+            return addOperationTransforms(name, options?.finalizeOperation
+                ? options.finalizeOperation(mock)
+                : mock);
+        };
+        return addOperationTransforms(name, builder);
+    };
     {
         const nonQueryNames = [
             ...Object.keys(mutations),

package/esm/jest.js

@@ -0,0 +1,120 @@
+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 { waitFor } from "@testing-library/dom";
+import { print } from "graphql";
+import { diff as jestDiff } from "jest-diff";
+let currentSpecResult;
+jasmine.getEnv().addReporter({
+    specStarted: (result) => currentSpecResult = result,
+});
+const afterTest = [];
+afterEach(async () => {
+    for (const hook of afterTest)
+        await hook();
+    afterTest.splice(0);
+});
+const diff = (a, b) => jestDiff(a, b, {
+    omitAnnotationLines: true,
+    // aColor: green,
+    // bColor: red,
+    // changeColor: inverse,
+    // commonColor: dim,
+    // patchColor: yellow,
+})
+    ?.replace(/\w+ \{/g, "{") // Remove class names
+    .replace(/\w+ \[/g, "["); // Remove array class names
+const getErrorMessage = (operation, mockLink) => {
+    const definition = operation.query.definitions[0];
+    const operationType = definition.kind === "OperationDefinition"
+        ? definition.operation
+        : "<unknown operation type>";
+    const key = JSON.stringify({
+        query: print(operation.query),
+    });
+    // Bypassing private variable
+    // 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`;
+    if (alts.length || Object.keys(operation.variables).length > 0) {
+        errorMessage += ` with variables ${dntShim.Deno.inspect(operation.variables, { depth: Infinity, colors: true })}`;
+    }
+    if (alts.length > 1) {
+        errorMessage +=
+            `, found ${alts.length} similar operations with differing variables:${alts
+                .slice(0, 9)
+                .map((o, i) => `\n${i + 1}.\n${diff(operation.variables, o.request.variables)}`)
+                .join("")}`;
+        if (alts.length > 9)
+            errorMessage += `\n... and ${alts.length - 9} more`;
+    }
+    else if (alts.length === 1) {
+        errorMessage += `, found similar operation with differing variables:\n${diff(operation.variables, alts[0].request.variables)}`;
+    }
+    return {
+        message: errorMessage,
+        stack: alts[0] && "stack" in alts[0] && typeof alts[0].stack === "string"
+            ? alts[0]?.stack
+            : undefined,
+    };
+};
+export const MockProvider = ({ mocks, stack, children }) => {
+    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;
+    }, [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"))
+                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 });
+            }
+            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);
+};

package/esm/plugin.cjs

@@ -2,6 +2,7 @@
 module.exports = {
     async plugin(schema, documents, config) {
         const { codegen } = await import("./codegen.js");
-        return (config.banner ?? "") + codegen(schema, documents.map((d) => ({ path: d.location, content: d.rawSDL })), { namingConvention: "change-case-all#pascalCase", ...config });
+        const { formatCode } = await import("./util.js");
+        return (config.banner ?? "") + await formatCode(codegen(schema, documents.map((d) => ({ path: d.location, content: d.rawSDL })), { namingConvention: "change-case-all#pascalCase", ...config }));
     },
 };

package/esm/util.js

@@ -1,4 +1,4 @@
-import { exec } from "node:child_process";
+import { spawn } from "node:child_process";
 export const raise = (error) => {
     if (typeof error === "string") {
         const err = new Error(error);
@@ -10,14 +10,28 @@ export const raise = (error) => {
 export const formatCode = async (input) => {
     try {
         return await new Promise((resolve, reject) => {
-            const process = exec("deno fmt -", (error, stdout, stderr) => {
-                if (error)
-                    return reject(error);
-                if (stderr)
-                    return reject(new Error(stderr));
-                resolve(stdout);
+            const process = spawn("deno", ["fmt", "-"], {
+                stdio: ["pipe", "pipe", "pipe"],
             });
-            process.stdin?.write(input);
+            let output = "";
+            let errorOutput = "";
+            process.stdout.on("data", (data) => {
+                output += data.toString();
+            });
+            process.stderr.on("data", (data) => {
+                errorOutput += data.toString();
+            });
+            process.on("close", (code) => {
+                if (code !== 0 || errorOutput) {
+                    reject(new Error(errorOutput || `Process exited with code ${code}`));
+                }
+                else
+                    resolve(output);
+            });
+            process.on("error", (error) => {
+                reject(error);
+            });
+            process.stdin.write(input);
             process.stdin?.end();
         });
     }

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "graphql-data-generator",
-  "version": "0.2.3",
+  "version": "0.3.0-alpha.0",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/vocesgraphql-data-generator/.git"
+    "url": "git+https://github.com/voces/graphql-data-generator.git"
   },
   "license": "MIT",
   "bugs": {
@@ -24,6 +24,12 @@
       "require": "./esm/plugin.cjs",
       "types": "./types/plugin.cjs",
       "default": "./esm/plugin.cjs"
+    },
+    "./jest": {
+      "import": "./esm/jest.js",
+      "require": "./esm/jest.js",
+      "types": "./types/jest.d.ts",
+      "default": "./esm/jest.js"
     }
   },
   "bin": {
@@ -31,7 +37,9 @@
   },
   "dependencies": {
     "@graphql-codegen/visitor-plugin-common": "*",
+    "@testing-library/dom": "*",
     "fast-glob": "*",
+    "jest-diff": "*",
     "@deno/shim-deno": "~0.18.0"
   },
   "devDependencies": {
@@ -40,6 +48,20 @@
   "_generatedBy": "dnt@dev",
   "peerDependencies": {
     "graphql": "*",
-    "@graphql-tools/graphql-tag-pluck": "*"
+    "@graphql-tools/graphql-tag-pluck": "*",
+    "react": "*",
+    "@types/react": "*",
+    "@apollo/client": "*"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    },
+    "@types/react": {
+      "optional": true
+    },
+    "@apollo/client": {
+      "optional": true
+    }
   }
 }

package/types/init.d.ts

@@ -12,5 +12,5 @@ export declare const init: <Query extends Record<string, {
 }>, Types extends Record<string, Record<string, unknown>>, Inputs extends Record<string, Record<string, unknown>>, Extra = object>(schema: string, queries: { [operation in keyof Query]: string; }, mutations: { [operation in keyof Mutation]: string; }, subscriptions: { [operation in keyof Subscription]: string; }, types: readonly (keyof Types & string)[], inputs: readonly (keyof Inputs & string)[], scalars: {
     [name: string]: ((typeName: string, fieldName: string) => unknown) | string | number | boolean | null;
 }, options?: {
-    finalizeOperation: <T extends OperationMock & Partial<Extra>>(operation: T) => T;
+    finalizeOperation?: <T extends OperationMock & Partial<Extra>>(operation: T) => T;
 }) => <Transforms extends MapObjectsToTransforms<Types & Inputs> & MapOperationsToTransforms<Query, Mutation, Subscription, Types, Inputs>>(fn: (b: Build<Query, Mutation, Subscription, Types, Inputs, ContravariantEmpty, Extra>) => Transforms) => Build<Query, Mutation, Subscription, Types, Inputs, Transforms, Extra>;

package/types/jest.d.ts

@@ -0,0 +1,8 @@
+import "./deps/esm.sh/@types/jest@29.5.3/index";
+import React from "react";
+import type { OperationMock } from "./types.js";
+export declare const MockProvider: ({ mocks, stack, children }: {
+    mocks: OperationMock[];
+    stack?: string;
+    children?: React.ReactNode;
+}) => React.JSX.Element;

package/types/types.d.ts

@@ -27,6 +27,7 @@ export type OperationMock<Data extends Record<string, unknown> = Record<string,
         errors?: GraphQLError[];
     };
     error?: Error;
+    stack?: string;
 };
 export type SimpleOperationMock<Data extends Record<string, unknown> = Record<string, unknown>, Variables = Record<string, unknown> | never> = {
     data: Data;