graphql-data-generator 0.1.7 → 0.2.0

package/README.md

@@ -84,6 +84,72 @@ const createPost = build.CreatePost({ data: { createPost: { id: "post-id" } } })
   .withAuthorId("user-3");
 ```
 
+## CLI options
+
+- `banner=file|copy`: Places copy at the beginning of the generated output. If a
+  file path is detected, will use the contents of the file.
+- `enums=[enums|literals|none|import:*]`: Describes how enums are generated.
+  - `enums`: Use TypeScript enum. E.g., `enum Status { Draft, Submitted }`
+  - `literals`: Use string literals. E.g.,
+    `type Status = "Draft" | "Submitted";`
+  - `none`: Skip generating of enums all together.
+  - `import:file` Import enums from the provided path. E.g.,
+    `import { Status } from "file";`
+- `exports=[operations|types]`: Toggle exporting of operations and/or types.
+- `notypenames`: Toggle automatic inclusion of `__typename`.
+- `operations=dir`: Restrict generation of operations to a specific directory.
+  Can be used multiple times for multiple directories.
+- `outfile=file`: Switch output to right to `file` instead of stdout.
+- `scalar=Scalar:Type`: Specify the type of an individual scalar. E.g.,
+  `type Scalar = Type;`
+- `scalars=file.json`: Specify multiple scalars from a json file.
+- `schema=file`: Specify the GraphQL schema file to use.
+- `typesFile=file`: Specify file generated by
+  [`@graphql-codegen`](https://the-guild.dev/graphql/codegen) to import types
+  from.
+
+## @graphql-codegen plugin
+
+A plugin shim exists for
+[`@graphql-codegen`](https://the-guild.dev/graphql/codegen):
+
+```ts
+import type { CodegenConfig } from "@graphql-codegen/cli";
+
+const config: CodegenConfig = {
+  schema: "src/schema.graphql",
+  documents: ["src/**/*.gql", "src/**/*.ts"],
+  generates: {
+    "./src/graphql/": {
+      preset: "client",
+      config: {
+        scalars: {
+          DateTime: "string",
+          URL: "string",
+        },
+      },
+    },
+    "./src/build/generated.ts": {
+      plugins: ["graphql-data-generator/plugin"],
+      config: {
+        typesFile: "../graphql/graphql.js",
+        scalars: {
+          DateTime: "string",
+          URL: "string",
+        },
+        banner: "// generated\n",
+      },
+    },
+  },
+};
+
+export default config;
+```
+
+Specifying a `typesFile` will skip outputting generated types and will instead
+depend on the types generated by `@graphql-codegen` itself. The `generated.ts`
+file can then be consumed by a `build` script similar to the above example.
+
 ## Patches
 
 A `patch` is similar to a `DeepPartial` with a few extensions. First, functions

package/esm/cli.js

@@ -9,14 +9,16 @@ import process from "node:process";
 const args = parseArgs({
     args: process.argv.slice(2),
     options: {
-        schema: { type: "string" },
-        scalars: { type: "string" },
+        banner: { type: "string" },
+        enums: { type: "string" },
+        exports: { type: "string", multiple: true },
+        notypenames: { type: "boolean" },
         operations: { type: "string", multiple: true },
-        scalar: { type: "string", multiple: true },
         outfile: { type: "string" },
-        enums: { type: "boolean" },
-        notypenames: { type: "boolean" },
-        exports: { type: "string", multiple: true },
+        scalar: { type: "string", multiple: true },
+        scalars: { type: "string" },
+        schema: { type: "string" },
+        typesFile: { type: "string" },
     },
 }).values;
 const findFirst = async (path) => {
@@ -39,14 +41,7 @@ if (!schemaPath) {
 }
 const operationDirs = args.operations?.map((v) => `${v}`) ?? ["."];
 const [schema, operations] = await loadFiles(schemaPath, operationDirs);
-const defaultScalars = {
-    Int: "number",
-    Float: "number",
-    String: "string",
-    Boolean: "boolean",
-    ID: "string",
-};
-const scalars = { ...defaultScalars };
+const scalars = {};
 if (args.scalars) {
     readFile;
     Object.assign(scalars, JSON.parse(await dntShim.Deno.readTextFile(args.scalars)));
@@ -69,12 +64,26 @@ const exports = args.exports
         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;
+}
 try {
-    const file = await formatCode(codegen(schema, operations, {
-        useEnums: args.enums ?? false,
+    const file = banner + await formatCode(codegen(schema, operations, {
+        enums: args.enums,
         includeTypenames: !args.notypenames,
         scalars,
         exports,
+        typesFile: args.typesFile,
     }));
     if (args.outfile)
         await dntShim.Deno.writeTextFile(args.outfile, file);

package/esm/codegen.js

@@ -1,8 +1,9 @@
 import { readFile } from "node:fs/promises";
-import { Kind, parse } from "graphql";
+import { Kind, OperationTypeNode, parse, printSchema } from "graphql";
 import fg from "fast-glob";
-import { join } from "node:path";
+import { join, relative } from "node:path";
 import { raise } from "./util.js";
+import process from "node:process";
 const getType = ({ type, ...props }) => {
     if (type.kind === "NamedType") {
         if (props.selections) {
@@ -222,6 +223,7 @@ const serializeType = (type, variables = false, depth = 0) => {
             return `"${type.value}"`;
     }
 };
+const drop = () => false;
 const serializeInput = (fields, optional, inputs, references) => ({
     kind: "Object",
     value: Object.fromEntries(fields.map((f) => [
@@ -278,8 +280,16 @@ const simpleType = (type, types, optional = true) => {
             };
     }
 };
-export const codegen = (schema, files, { useEnums = true, scalars = {}, includeTypenames = true, exports = [], } = {}) => {
-    const schemaDoc = parse(schema);
+const defaultScalars = {
+    Int: "number",
+    Float: "number",
+    String: "string",
+    Boolean: "boolean",
+    ID: "string",
+};
+export const codegen = (schema, files, { enums = "literals", scalars, includeTypenames = true, exports = [], typesFile, } = {}) => {
+    const schemaDoc = parse(typeof schema === "string" ? schema : printSchema(schema));
+    scalars = { ...defaultScalars, ...scalars };
     const types = {};
     const inputs = {};
     const fragments = {};
@@ -290,16 +300,36 @@ export const codegen = (schema, files, { useEnums = true, scalars = {}, includeT
     let query = {};
     let mutation = {};
     let subscription = {};
+    let queryKey = "Query";
+    let mutationKey = "Mutation";
+    let subscriptionKey = "Subscription";
     for (const definition of schemaDoc.definitions) {
         switch (definition.kind) {
+            case "SchemaDefinition":
+                {
+                    for (const operationType of definition.operationTypes) {
+                        switch (operationType.operation) {
+                            case OperationTypeNode.QUERY:
+                                queryKey = operationType.type.name.value;
+                                break;
+                            case OperationTypeNode.MUTATION:
+                                mutationKey = operationType.type.name.value;
+                                break;
+                            case OperationTypeNode.SUBSCRIPTION:
+                                subscriptionKey = operationType.type.name.value;
+                                break;
+                        }
+                    }
+                }
+                break;
             case "ObjectTypeDefinition":
-                if (definition.name.value === "Query") {
+                if (definition.name.value === queryKey) {
                     query = Object.fromEntries(definition.fields?.map((f) => [f.name.value, f]) ?? []);
                 }
-                else if (definition.name.value === "Mutation") {
+                else if (definition.name.value === mutationKey) {
                     mutation = Object.fromEntries(definition.fields?.map((f) => [f.name.value, f]) ?? []);
                 }
-                else if (definition.name.value === "Subscription") {
+                else if (definition.name.value === subscriptionKey) {
                     subscription = Object.fromEntries(definition.fields?.map((f) => [f.name.value, f]) ?? []);
                 }
                 else
@@ -375,7 +405,7 @@ export const codegen = (schema, files, { useEnums = true, scalars = {}, includeT
         }
     }
     const operationDataName = (name, type) => {
-        if (inputs[name] || types[name]) {
+        if (inputs[name] || types[name] || typesFile) {
             return `${name}${type[0].toUpperCase()}${type.slice(1)}`;
         }
         for (const key in operations) {
@@ -387,6 +417,7 @@ export const codegen = (schema, files, { useEnums = true, scalars = {}, includeT
         return name;
     };
     const handledInputs = new Set();
+    const filterOutputTypes = typesFile ? drop : Boolean;
     const serializedTypes = Object.entries(operations).filter(([, v]) => v.length)
         .flatMap(([operationType, collection]) => [
         ...collection.flatMap((c) => c.definition.variableDefinitions?.map((v) => {
@@ -434,17 +465,19 @@ export const codegen = (schema, files, { useEnums = true, scalars = {}, includeT
                 handledInputs.add(current);
             }
             // return `type ${type.value} = ${serializeType(inputType)};`;
-        }).filter(Boolean)),
+        }).filter(Boolean)).filter(filterOutputTypes),
         ...collection.flatMap((o) => {
             const name = operationDataName(o.name, operationType);
+            const resolvedOperationType = getOperationType(o.definition, types, fragments, roots[o.definition.operation], references, includeTypenames);
             const arr = [
-                `${exports.includes("operations") ? "export " : ""}type ${name} = ${serializeType(getOperationType(o.definition, types, fragments, roots[o.definition.operation], references, includeTypenames), false)};`,
+                `${exports.includes("operations") ? "export " : ""}type ${name} = ${serializeType(resolvedOperationType, false, undefined)};`,
             ];
             if (o.definition.variableDefinitions?.length) {
                 arr.push(`${exports.includes("operations") ? "export " : ""}type ${name}Variables = ${serializeType(getOperationVariables(o.definition, references), true)};`);
             }
             return arr;
-        }),
+        }).filter(filterOutputTypes),
+        ,
         `export type ${operationNames[operationType].types} = {
 ${collection.map((o) => {
             const name = operationDataName(o.name, operationType);
@@ -455,16 +488,16 @@ ${collection.map((o) => {
 };
 
 export const ${operationNames[operationType].list} = {
-${collection.map((o) => `  ${o.name}: "${o.path}",`).join("\n")}
+${collection.map((o) => `  ${o.name}: "${relative(process.cwd(), o.path)}",`).join("\n")}
 };`,
     ]);
     if (handledInputs.size) {
-        serializedTypes.unshift(...Array.from(handledInputs).map((i) => {
+        serializedTypes.unshift(...(Array.from(handledInputs)).map((i) => {
             const def = inputs[i]?.[0];
             if (!def)
                 throw new Error(`Could not find input '${i}'`);
             return `${exports.includes("types") ? "export " : ""}type ${i} = ${serializeType(serializeInput(def.fields ?? [], false, {}, references), true)};`;
-        }), `export type Inputs = {
+        }).filter(filterOutputTypes), `export type Inputs = {
 ${Array.from(handledInputs).map((i) => `  ${i}: ${i};`).join("\n")}
 };`, `export const inputs = [${Array.from(handledInputs).map((i) => `"${i}"`).join(", ")}] as const;`);
     }
@@ -474,7 +507,7 @@ ${Array.from(handledInputs).map((i) => `  ${i}: ${i};`).join("\n")}
     if (usedTypes.length) {
         serializedTypes.unshift(...usedTypes.map(([name, type, usage]) => `${exports.includes("types") ? "export " : ""}type ${name} = {
 ${includeTypenames ? `  __typename: "${name}";\n` : ""}${type.fields?.filter((f) => usage.has(f.name.value)).map((v) => `  ${v.name.value}: ${serializeType(simpleType(v.type, types))};`).join("\n")}
-};`), `export type Types = {
+};`).filter(filterOutputTypes), `export type Types = {
 ${usedTypes.map(([name]) => `  ${name}: ${name};`).join("\n")}
 };`, `export const types = [${usedTypes.map(([name]) => `"${name}"`).join(", ")}] as const;`);
     }
@@ -485,15 +518,36 @@ ${usedTypes.map(([name]) => `  ${name}: ${name};`).join("\n")}
             return `${exports.includes("types") ? "export " : ""}type ${r.name.value} = ${scalars[r.name.value] ??
                 raise(`Could not find scalar '${r.name.value}'`)};`;
         }
-        if (useEnums) {
+        if (enums === "enums") {
             return `${exports.includes("types") ? "export " : ""}enum ${r.name.value} {
   ${r.values?.map((r) => r.name.value).join(",\n  ")},
 }`;
         }
-        else {
+        else if (enums === "literals") {
             return `${exports.includes("types") ? "export " : ""}type ${r.name.value} = ${r.values?.map((r) => `"${r.name.value}"`).join(" | ")};`;
         }
-    }));
+    }).filter(filterOutputTypes));
+    if (typesFile) {
+        const operationsImports = (operations) => operations.flatMap((o) => {
+            const prefix = operationDataName(o.name, o.definition.operation);
+            return o.definition.variableDefinitions?.length
+                ? [`${prefix}`, `${prefix}Variables`]
+                : `${prefix}`;
+        });
+        const imports = [
+            ...operationsImports(operations.query),
+            ...operationsImports(operations.mutation),
+            ...operationsImports(operations.subscription),
+            ...usedTypes.map((u) => u[0]),
+            ...Array.from(handledInputs),
+        ];
+        serializedTypes.unshift(`import {\n  ${imports.sort().join(",\n  ")},
+} from "${typesFile}";`);
+    }
+    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)}";`);
+    }
     return serializedTypes.join("\n\n") + "\n";
 };
 export const loadFiles = async (schemaPath, operationDirs) => {

package/esm/init.js

@@ -1,10 +1,35 @@
 import { readFileSync } from "node:fs";
-import { parse } from "graphql";
+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";
 const files = {};
-const loadFile = (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(join(dirname(path), fragmentPath))));
+const getOperationContentMap = {};
+const getOperationContent = (path, operationName) => {
+    const existing = getOperationContentMap[path];
+    if (existing) {
+        if (existing.kind === Kind.DOCUMENT)
+            return existing;
+        return getOperationContentMap[path][operationName];
+    }
+    const fileContent = readFileSync(path, "utf-8").replace(/#import "(.*)"/, (_, fragmentPath) => loadFile(join(dirname(path), fragmentPath)));
+    try {
+        const sources = gqlPluckFromCodeStringSync(path, fileContent);
+        getOperationContentMap[path] = Object.fromEntries(sources.map((s) => {
+            const document = parse(s);
+            const firstOp = document.definitions.find((d) => d.kind === Kind.OPERATION_DEFINITION);
+            if (!firstOp)
+                throw new Error(`Cound not find an operation in ${path}`);
+            return [firstOp.name?.value, document];
+        }));
+    }
+    catch {
+        getOperationContentMap[path] = parse(fileContent);
+    }
+    return getOperationContent(path, operationName);
+};
 // - 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);
@@ -81,7 +106,7 @@ export const init = (schema, queries, mutations, subscriptions, types, inputs, s
         return obj;
     };
     const operationBuilder = (name, path) => addOperationTransforms(name, (...patches) => {
-        const query = files[path] ?? loadFile(path);
+        const query = getOperationContent(path, name);
         if (transforms[name] && "default" in transforms[name]) {
             patches = [transforms[name].default, ...patches];
         }

package/esm/plugin.cjs

@@ -0,0 +1,7 @@
+"use strict";
+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 })), config);
+    },
+};

package/esm/proxy.js

@@ -113,7 +113,9 @@ const resolveConcreteType = (definitions, definition, patch, prev) => {
     if (options.length === 1)
         return options[0];
     for (const field in patch) {
-        options = options.filter((o) => o.fields?.some((f) => f.name.value === field));
+        options = options.filter((o) => field === "__typename"
+            ? o.name.value === patch[field]
+            : o.fields?.some((f) => f.name.value === field));
         if (options.length === 1)
             return options[0];
     }
@@ -560,7 +562,7 @@ const constToValue = (value) => {
     }
 };
 export const operation = (definitions, scalars, query, ...patches) => {
-    const document = parse(query);
+    const document = typeof query === "string" ? parse(query) : query;
     const operations = document.definitions.filter((d) => d.kind === Kind.OPERATION_DEFINITION);
     if (operations.length !== 1) {
         throw new Error(`Expected 1 operation, got ${operations.length}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphql-data-generator",
-  "version": "0.1.7",
+  "version": "0.2.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/vocesgraphql-data-generator/.git"
@@ -14,10 +14,16 @@
   "types": "./types/index.d.ts",
   "exports": {
     ".": {
-      "import": {
-        "types": "./types/index.d.ts",
-        "default": "./esm/index.js"
-      }
+      "import": "./esm/index.js",
+      "require": "./esm/index.js",
+      "types": "./types/index.d.ts",
+      "default": "./esm/index.js"
+    },
+    "./plugin": {
+      "import": "./esm/plugin.cjs",
+      "require": "./esm/plugin.cjs",
+      "types": "./types/plugin.cjs",
+      "default": "./esm/plugin.cjs"
     }
   },
   "bin": {
@@ -32,6 +38,7 @@
   },
   "_generatedBy": "dnt@dev",
   "peerDependencies": {
-    "graphql": "*"
+    "graphql": "*",
+    "@graphql-tools/graphql-tag-pluck": "*"
   }
 }

package/types/codegen.d.ts

@@ -1,11 +1,13 @@
-export declare const codegen: (schema: string, files: {
+import type { GraphQLSchema } from "graphql";
+export declare const codegen: (schema: GraphQLSchema | string, files: {
     path: string;
     content: string;
-}[], { useEnums, scalars, includeTypenames, exports, }?: {
-    useEnums?: boolean;
+}[], { enums, scalars, includeTypenames, exports, typesFile, }?: {
+    enums?: string;
     scalars?: Record<string, string | undefined>;
     includeTypenames?: boolean;
     exports?: ("types" | "operations")[];
+    typesFile?: string;
 }) => string;
 export declare const loadFiles: (schemaPath: string, operationDirs: string[]) => Promise<[schema: string, operations: {
     path: string;

package/types/plugin.d.cts

@@ -0,0 +1 @@
+export function plugin(schema: any, documents: any, config: any): Promise<string>;

package/types/proxy.d.ts

@@ -1,8 +1,8 @@
-import type { DefinitionNode, GraphQLError } from "graphql";
+import type { DefinitionNode, DocumentNode, GraphQLError } 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">> & {
+export declare const operation: <O extends SimpleOperationMock, Extra = object>(definitions: readonly DefinitionNode[], scalars: Record<string, unknown | ((typename: string) => unknown)>, query: string | DocumentNode, ...patches: (Patch<Omit<O, "error" | "errors">> & {
     error?: Error;
     errors?: GraphQLError[];
 } & Partial<Extra>)[]) => OperationMock<O["data"], O["variables"]> & Partial<Extra>;