graphql-data-generator 0.1.0

package/esm/init.js

@@ -0,0 +1,133 @@
+import { readFileSync } from "node:fs";
+import { parse } from "graphql";
+import { dirname, join } from "node:path";
+import { operation, proxy, withGetDefaultPatch } from "./proxy.js";
+import { toObject } from "./util.js";
+const files = {};
+const loadFile = (path) => files[path] = readFileSync(path, "utf-8").replace(/#import "(.*)"/, (_, fragmentPath) => loadFile(join(dirname(path), fragmentPath)));
+// - Types will be suffixed with their type: fooQuery or fooMutation
+export const init = (schema, queries, mutations, subscriptions, types, inputs, scalars, options) => (fn) => {
+    const doc = parse(schema);
+    const build = {};
+    const transforms = fn(build);
+    const addObjectTransforms = (type, obj) => {
+        Object.defineProperty(obj, "patch", {
+            value: (...patches) => build[type]((typeof obj === "function" ? obj() : obj), ...patches),
+        });
+        Object.defineProperties(obj, Object.fromEntries(Object.entries(transforms[type] ?? {}).map(([name, fn]) => [name, {
+                value: (...args) => {
+                    const prev = typeof obj === "function" ? obj() : obj;
+                    const patch = (typeof fn === "function"
+                        ? fn(prev, ...args)
+                        : fn);
+                    return build[type](prev, patch);
+                },
+            }])));
+        return obj;
+    };
+    const wrap = (type, patches) => withGetDefaultPatch((type) => transforms[type]?.default, () => toObject(proxy(doc.definitions, scalars, type, ...patches)));
+    const objectBuilder = (type) => addObjectTransforms(type, (...patches) => {
+        if (transforms[type] && "default" in transforms[type]) {
+            patches = [
+                transforms[type].default,
+                ...patches,
+            ];
+        }
+        return addObjectTransforms(type, wrap(type, patches));
+    });
+    for (const type of types) {
+        build[type] = objectBuilder(type);
+    }
+    for (const input of inputs) {
+        build[input] = objectBuilder(input);
+    }
+    const resolveOperationConflicts = (operation, kind, otherNames) => {
+        if (!otherNames.includes(operation))
+            return operation;
+        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, Object.fromEntries(Object.entries(transforms[operation] ?? {}).map(([name, fn]) => [name, {
+                value: (...args) => {
+                    const prev = typeof obj === "function" ? obj() : obj;
+                    const prevInput = {
+                        data: prev.result.data,
+                        variables: prev.request.variables,
+                        error: prev.error,
+                        errors: prev.result.errors,
+                    };
+                    const operationFn = fn;
+                    const patch = (typeof operationFn === "function"
+                        ? operationFn(prevInput, ...args)
+                        : operationFn);
+                    const builder = build[operation];
+                    return builder(prevInput, patch);
+                },
+            }])));
+        return obj;
+    };
+    const operationBuilder = (name, path) => addOperationTransforms(name, (...patches) => {
+        const query = files[path] ?? loadFile(path);
+        if (transforms[name] && "default" in transforms[name]) {
+            patches = [transforms[name].default, ...patches];
+        }
+        const result = toObject(operation(doc.definitions, scalars, query, ...patches));
+        return addOperationTransforms(name, options?.finalizeOperation
+            ? options.finalizeOperation(result)
+            : result);
+    });
+    {
+        const nonQueryNames = [
+            ...Object.keys(mutations),
+            ...Object.keys(subscriptions),
+            ...types,
+            ...inputs,
+        ];
+        for (const query in queries) {
+            build[resolveOperationConflicts(query, "query", nonQueryNames)] =
+                // deno-lint-ignore no-explicit-any
+                operationBuilder(query, queries[query]);
+        }
+    }
+    {
+        const nonMutationNames = [
+            ...Object.keys(queries),
+            ...Object.keys(subscriptions),
+            ...types,
+            ...inputs,
+        ];
+        for (const mutation in mutations) {
+            build[resolveOperationConflicts(mutation, "mutation", nonMutationNames)] =
+                // deno-lint-ignore no-explicit-any
+                operationBuilder(mutation, mutations[mutation]);
+        }
+    }
+    {
+        const nonSubscriptionNames = [
+            ...Object.keys(queries),
+            ...Object.keys(mutations),
+            ...types,
+            ...inputs,
+        ];
+        for (const subscription in subscriptions) {
+            build[resolveOperationConflicts(subscription, "subscription", nonSubscriptionNames)
+            // deno-lint-ignore no-explicit-any
+            ] = operationBuilder(subscription, subscriptions[subscription]);
+        }
+    }
+    return build;
+};

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/esm/proxy.d.ts

@@ -0,0 +1,8 @@
+import type { DefinitionNode } from "graphql";
+import type { OperationMock, Patch, SimpleOperationMock } from "./types.js";
+export declare const withGetDefaultPatch: <T>(newGetDefaultPatch: <U>(__typename: string) => Patch<U> | ((prev: U) => Patch<U> | undefined) | undefined, fn: () => T) => T;
+export declare const proxy: <T>(definitions: readonly DefinitionNode[], scalars: Record<string, unknown | ((typename: string) => unknown)>, type: string, ...patches: (Patch<T> | ((prev: T) => Patch<T>))[]) => T;
+export declare const operation: <O extends SimpleOperationMock, Extra = object>(definitions: readonly DefinitionNode[], scalars: Record<string, unknown | ((typename: string) => unknown)>, query: string, ...patches: (Patch<Omit<O, "error" | "errors">> & {
+    error?: O["error"];
+    errors?: O["errors"];
+} & Partial<Extra>)[]) => OperationMock<O["data"], O["variables"]> & Partial<Extra>;