graphql-data-generator 0.1.4 → 0.1.6

package/esm/cli.js

@@ -14,8 +14,9 @@ const args = parseArgs({
         operations: { type: "string", multiple: true },
         scalar: { type: "string", multiple: true },
         outfile: { type: "string" },
-        useEnums: { type: "boolean", default: false },
-        includeTypenames: { type: "boolean", default: true },
+        enums: { type: "boolean" },
+        notypenames: { type: "boolean" },
+        exports: { type: "string", multiple: true },
     },
 }).values;
 const findFirst = async (path) => {
@@ -59,11 +60,21 @@ if (args.scalar) {
         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(", ")}`);
+        }
+        return true;
+    })
+    : [];
 try {
     const file = await formatCode(codegen(schema, operations, {
-        useEnums: args.useEnums,
-        includeTypenames: args.includeTypenames,
+        useEnums: args.enums ?? false,
+        includeTypenames: !args.notypenames,
         scalars,
+        exports,
     }));
     if (args.outfile)
         await dntShim.Deno.writeTextFile(args.outfile, file);

package/esm/codegen.js

@@ -278,7 +278,7 @@ const simpleType = (type, types, optional = true) => {
             };
     }
 };
-export const codegen = (schema, files, { useEnums = true, scalars = {}, includeTypenames = true } = {}) => {
+export const codegen = (schema, files, { useEnums = true, scalars = {}, includeTypenames = true, exports = [], } = {}) => {
     const schemaDoc = parse(schema);
     const types = {};
     const inputs = {};
@@ -374,9 +374,21 @@ export const codegen = (schema, files, { useEnums = true, scalars = {}, includeT
             }
         }
     }
+    const operationDataName = (name, type) => {
+        if (inputs[name] || types[name]) {
+            return `${name}${type[0].toUpperCase()}${type.slice(1)}`;
+        }
+        for (const key in operations) {
+            if (type === key)
+                continue;
+            if (operations[key].some((o) => o.name === name))
+                return `${name}${type[0].toUpperCase()}${type.slice(1)}`;
+        }
+        return name;
+    };
     const handledInputs = new Set();
     const serializedTypes = Object.entries(operations).filter(([, v]) => v.length)
-        .flatMap(([name, collection]) => [
+        .flatMap(([operationType, collection]) => [
         ...collection.flatMap((c) => c.definition.variableDefinitions?.map((v) => {
             let type = getType({
                 type: v.type,
@@ -423,20 +435,26 @@ export const codegen = (schema, files, { useEnums = true, scalars = {}, includeT
             }
             // return `type ${type.value} = ${serializeType(inputType)};`;
         }).filter(Boolean)),
-        `export type ${operationNames[name].types} = {
+        ...collection.flatMap((o) => {
+            const name = operationDataName(o.name, operationType);
+            const arr = [
+                `${exports.includes("operations") ? "export " : ""}type ${name} = ${serializeType(getOperationType(o.definition, types, fragments, roots[o.definition.operation], references, includeTypenames), false)};`,
+            ];
+            if (o.definition.variableDefinitions?.length) {
+                arr.push(`${exports.includes("operations") ? "export " : ""}type ${name}Variables = ${serializeType(getOperationVariables(o.definition, references), true)};`);
+            }
+            return arr;
+        }),
+        `export type ${operationNames[operationType].types} = {
 ${collection.map((o) => {
-            const data = serializeType(getOperationType(o.definition, types, fragments, roots[o.definition.operation], references, includeTypenames), false, 2);
-            const variables = getOperationVariables(o.definition, references);
-            return `  ${o.name}: {
-    data: ${data};${variables.kind === "Object" && Object.keys(variables.value).length
-                ? `
-    variables: ${serializeType(variables, true, 2)};`
-                : ""}
-  };`;
+            const name = operationDataName(o.name, operationType);
+            return `  ${o.name}: { data: ${name};${o.definition.variableDefinitions?.length
+                ? ` variables: ${name}Variables;`
+                : ""} };`;
         }).join("\n")}
 };
 
-export const ${operationNames[name].list} = {
+export const ${operationNames[operationType].list} = {
 ${collection.map((o) => `  ${o.name}: "${o.path}",`).join("\n")}
 };`,
     ]);
@@ -445,7 +463,7 @@ ${collection.map((o) => `  ${o.name}: "${o.path}",`).join("\n")}
             const def = inputs[i]?.[0];
             if (!def)
                 throw new Error(`Could not find input '${i}'`);
-            return `type ${i} = ${serializeType(serializeInput(def.fields ?? [], false, {}, references))};`;
+            return `${exports.includes("types") ? "export " : ""}type ${i} = ${serializeType(serializeInput(def.fields ?? [], false, {}, references), true)};`;
         }), `export type Inputs = {
 ${Array.from(handledInputs).map((i) => `  ${i}: ${i};`).join("\n")}
 };`, `export const inputs = [${Array.from(handledInputs).map((i) => `"${i}"`).join(", ")}] as const;`);
@@ -454,7 +472,7 @@ ${Array.from(handledInputs).map((i) => `  ${i}: ${i};`).join("\n")}
         .map(([name, info]) => [name, ...info])
         .filter((data) => data[1].kind === "ObjectTypeDefinition" && data[2].size > 0);
     if (usedTypes.length) {
-        serializedTypes.unshift(...usedTypes.map(([name, type, usage]) => `type ${name} = {
+        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 = {
 ${usedTypes.map(([name]) => `  ${name}: ${name};`).join("\n")}
@@ -464,16 +482,16 @@ ${usedTypes.map(([name]) => `  ${name}: ${name};`).join("\n")}
     serializedTypes.unshift(...usedReferences.map((r) => {
         // TODO: warn if missing and use unknown instead
         if (r.kind === "ScalarTypeDefinition") {
-            return `type ${r.name.value} = ${scalars[r.name.value] ??
+            return `${exports.includes("types") ? "export " : ""}type ${r.name.value} = ${scalars[r.name.value] ??
                 raise(`Could not find scalar '${r.name.value}'`)};`;
         }
         if (useEnums) {
-            return `enum ${r.name.value} {
+            return `${exports.includes("types") ? "export " : ""}enum ${r.name.value} {
   ${r.values?.map((r) => r.name.value).join(",\n  ")},
 }`;
         }
         else {
-            return `type ${r.name.value} = ${r.values?.map((r) => `"${r.name.value}"`).join(" | ")};`;
+            return `${exports.includes("types") ? "export " : ""}type ${r.name.value} = ${r.values?.map((r) => `"${r.name.value}"`).join(" | ")};`;
         }
     }));
     return serializedTypes.join("\n\n") + "\n";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphql-data-generator",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/vocesgraphql-data-generator/.git"
@@ -25,11 +25,13 @@
   },
   "dependencies": {
     "fast-glob": "*",
-    "graphql": "*",
     "@deno/shim-deno": "~0.18.0"
   },
   "devDependencies": {
     "@types/node": "^20.9.0"
   },
-  "_generatedBy": "dnt@dev"
+  "_generatedBy": "dnt@dev",
+  "peerDependencies": {
+    "graphql": "*"
+  }
 }

package/types/codegen.d.ts

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

package/types/extendedTypes.d.ts

@@ -40,7 +40,7 @@ type MapOperationsToBuilders<T, Transforms, Extra> = {
         data: infer U;
     } ? U extends Record<string, unknown> ? U : Record<string, unknown> : Record<string, unknown>, T[K] extends {
         variables: infer U;
-    } ? U : unknown, K extends keyof Transforms ? Transforms[K] : ContravariantEmpty, Extra>;
+    } ? U : never, K extends keyof Transforms ? Transforms[K] : ContravariantEmpty, Extra>;
 };
 type ResolveOperationConflicts<T, Name extends string, A, B, C, D> = Omit<T, keyof A | keyof B | keyof C | keyof D> & PrefixKeys<Pick<T, keyof T & (keyof A | keyof B | keyof C | keyof D)>, Name>;
 type ResolveConflicts<Queries, Mutations, Subscriptions, Types, Inputs> = ResolveOperationConflicts<Queries, "queries", Mutations, Subscriptions, Types, Inputs> & ResolveOperationConflicts<Mutations, "mutations", Queries, Subscriptions, Types, Inputs> & ResolveOperationConflicts<Subscriptions, "subscriptions", Queries, Mutations, Types, Inputs>;