graphql-data-generator 0.2.1 → 0.2.3

package/README.md

@@ -96,6 +96,10 @@ const createPost = build.CreatePost({ data: { createPost: { id: "post-id" } } })
   - `import:file` Import enums from the provided path. E.g.,
     `import { Status } from "file";`
 - `exports=[operations|types]`: Toggle exporting of operations and/or types.
+- `namingConvention=NamingConvention`: Specify a
+  [`NamingConvention`](https://the-guild.dev/graphql/codegen/docs/config-reference/naming-convention)
+  for generated types. Defaults to `change-case-all#pascalCase` if using the
+  plugin, otherwise defaults to `keep`.
 - `notypenames`: Toggle automatic inclusion of `__typename`.
 - `operations=dir`: Restrict generation of operations to a specific directory.
   Can be used multiple times for multiple directories.

package/esm/cli.js

@@ -12,6 +12,7 @@ const args = parseArgs({
         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" },
@@ -84,6 +85,7 @@ try {
         scalars,
         exports,
         typesFile: args.typesFile,
+        namingConvention: args.namingConvention,
     }));
     if (args.outfile)
         await dntShim.Deno.writeTextFile(args.outfile, file);

package/esm/codegen.js

@@ -4,6 +4,7 @@ import fg from "fast-glob";
 import { join, relative } from "node:path";
 import { raise } from "./util.js";
 import process from "node:process";
+import { convertFactory, } from "@graphql-codegen/visitor-plugin-common";
 const getType = ({ type, ...props }) => {
     if (type.kind === "NamedType") {
         if (props.selections) {
@@ -287,7 +288,10 @@ const defaultScalars = {
     Boolean: "boolean",
     ID: "string",
 };
-export const codegen = (schema, files, { enums = "literals", scalars, includeTypenames = true, exports = [], typesFile, } = {}) => {
+export const codegen = (schema, files, { enums = "literals", scalars, includeTypenames = true, exports = [], typesFile, namingConvention = "keep", } = {}) => {
+    const rename = typesFile
+        ? convertFactory({ namingConvention })
+        : (v) => v;
     const schemaDoc = parse(typeof schema === "string" ? schema : printSchema(schema));
     scalars = { ...defaultScalars, ...scalars };
     const types = {};
@@ -389,6 +393,10 @@ export const codegen = (schema, files, { enums = "literals", scalars, includeTyp
                         console.warn(`Skipping unnamed operation in '${path}'`);
                         continue;
                     }
+                    if (operations[definition.operation].some((o) => o.name === name)) {
+                        console.warn(`Skipping duplicate operation '${name}'`);
+                        continue;
+                    }
                     operations[definition.operation].push({
                         name,
                         path,
@@ -404,9 +412,10 @@ export const codegen = (schema, files, { enums = "literals", scalars, includeTyp
             }
         }
     }
-    const operationDataName = (name, type) => {
+    const operationDataName = (operation, type) => {
+        const name = operation.name;
         if (inputs[name] || types[name] || typesFile) {
-            return `${name}${type[0].toUpperCase()}${type.slice(1)}`;
+            return rename(`${name}${type[0].toUpperCase()}${type.slice(1)}`);
         }
         for (const key in operations) {
             if (type === key)
@@ -467,7 +476,7 @@ export const codegen = (schema, files, { enums = "literals", scalars, includeTyp
             // return `type ${type.value} = ${serializeType(inputType)};`;
         }).filter(Boolean)).filter(filterOutputTypes),
         ...collection.flatMap((o) => {
-            const name = operationDataName(o.name, operationType);
+            const name = operationDataName(o, operationType);
             const resolvedOperationType = getOperationType(o.definition, types, fragments, roots[o.definition.operation], references, includeTypenames);
             const arr = [
                 `${exports.includes("operations") ? "export " : ""}type ${name} = ${serializeType(resolvedOperationType, false, undefined)};`,
@@ -480,7 +489,7 @@ export const codegen = (schema, files, { enums = "literals", scalars, includeTyp
         ,
         `export type ${operationNames[operationType].types} = {
 ${collection.map((o) => {
-            const name = operationDataName(o.name, operationType);
+            const name = operationDataName(o, operationType);
             return `  ${o.name}: { data: ${name};${o.definition.variableDefinitions?.length
                 ? ` variables: ${name}Variables;`
                 : ""} };`;
@@ -498,7 +507,7 @@ ${collection.map((o) => `  ${o.name}: "${relative(process.cwd(), o.path)}",`).jo
                 throw new Error(`Could not find input '${i}'`);
             return `${exports.includes("types") ? "export " : ""}type ${i} = ${serializeType(serializeInput(def.fields ?? [], false, {}, references), true)};`;
         }).filter(filterOutputTypes), `export type Inputs = {
-${Array.from(handledInputs).map((i) => `  ${i}: ${i};`).join("\n")}
+${Array.from(handledInputs).map((i) => `  ${i}: ${rename(i)};`).join("\n")}
 };`, `export const inputs = [${Array.from(handledInputs).map((i) => `"${i}"`).join(", ")}] as const;`);
     }
     const usedTypes = Object.entries(types)
@@ -508,7 +517,7 @@ ${Array.from(handledInputs).map((i) => `  ${i}: ${i};`).join("\n")}
         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")}
 };`).filter(filterOutputTypes), `export type Types = {
-${usedTypes.map(([name]) => `  ${name}: ${name};`).join("\n")}
+${usedTypes.map(([name]) => `  ${name}: ${rename(name)};`).join("\n")}
 };`, `export const types = [${usedTypes.map(([name]) => `"${name}"`).join(", ")}] as const;`);
     }
     const usedReferences = Object.values(references).filter((r) => r[1]).map((r) => r[0]);
@@ -529,7 +538,7 @@ ${usedTypes.map(([name]) => `  ${name}: ${name};`).join("\n")}
     }).filter(filterOutputTypes));
     if (typesFile) {
         const operationsImports = (operations) => operations.flatMap((o) => {
-            const prefix = operationDataName(o.name, o.definition.operation);
+            const prefix = operationDataName(o, o.definition.operation);
             return o.definition.variableDefinitions?.length
                 ? [`${prefix}`, `${prefix}Variables`]
                 : `${prefix}`;
@@ -538,8 +547,8 @@ ${usedTypes.map(([name]) => `  ${name}: ${name};`).join("\n")}
             ...operationsImports(operations.query),
             ...operationsImports(operations.mutation),
             ...operationsImports(operations.subscription),
-            ...usedTypes.map((u) => u[0]),
-            ...Array.from(handledInputs),
+            ...usedTypes.map((u) => rename(u[0])),
+            ...Array.from(handledInputs, (i) => rename(i)),
         ];
         serializedTypes.unshift(`import {\n  ${imports.sort().join(",\n  ")},
 } from "${typesFile}";`);

package/esm/plugin.cjs

@@ -2,6 +2,6 @@
 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);
+        return (config.banner ?? "") + codegen(schema, documents.map((d) => ({ path: d.location, content: d.rawSDL })), { namingConvention: "change-case-all#pascalCase", ...config });
     },
 };

package/esm/proxy.js

@@ -62,7 +62,7 @@ const resolveType = (definitions, path) => {
                 }
                 type = argument.type;
             }
-            while (parts[i + 2]?.match(/^\d$/)) {
+            while (parts[i + 2]?.match(/^\d+$/)) {
                 if (type.kind === Kind.NON_NULL_TYPE)
                     type = type.type;
                 if (type.kind !== Kind.LIST_TYPE)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphql-data-generator",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/vocesgraphql-data-generator/.git"
@@ -30,6 +30,7 @@
     "graphql-data-generator": "./esm/cli.js"
   },
   "dependencies": {
+    "@graphql-codegen/visitor-plugin-common": "*",
     "fast-glob": "*",
     "@deno/shim-deno": "~0.18.0"
   },

package/types/codegen.d.ts

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