@nxgt/graphql-codegen-zod 0.1.0 → 0.2.0

package/dist/index.js

@@ -2,8 +2,8 @@
 import { checkConstraints } from "@nxgt/graphql-validation/codegen";
 import {
   isInputObjectType as isInputObjectType7,
-  isInterfaceType as isInterfaceType2,
-  isObjectType as isObjectType2
+  isInterfaceType as isInterfaceType4,
+  isObjectType as isObjectType6
 } from "graphql";
 
 // src/imports.ts
@@ -51,10 +51,18 @@ class Naming {
     return this.#wrap(this.#convert(`${parent}${underscore}${this.#convert(field)}Args`));
   }
   variables(operation, kind) {
+    return this.#wrap(this.#convert(`${operation}${this.#suffix(operation, kind)}Variables`));
+  }
+  result(operation, kind) {
+    return this.#wrap(this.#convert(`${operation}${this.#suffix(operation, kind)}`));
+  }
+  fragment(name) {
+    return this.#wrap(this.#convert(`${name}${this.#suffix(name, "fragment")}`));
+  }
+  #suffix(operation, kind) {
     const type = changeCase.pascalCase(kind);
     const { omitOperationSuffix, dedupeOperationSuffix } = this.#config;
-    const suffix = omitOperationSuffix || dedupeOperationSuffix && operation.toLowerCase().endsWith(type.toLowerCase()) ? "" : type;
-    return this.#wrap(this.#convert(`${operation}${suffix}Variables`));
+    return omitOperationSuffix || dedupeOperationSuffix && operation.toLowerCase().endsWith(type.toLowerCase()) ? "" : type;
   }
   schema(type) {
     return `${this.#config.schemaPrefix ?? "z"}${type}`;
@@ -124,6 +132,456 @@ function caseNamed(spec) {
   throw new Error(`@nxgt/graphql-codegen-zod: namingConvention "${spec}" is not one this plugin reads. Use 'keep', a function, or 'change-case-all#<case>' with one of ${Object.keys(cases["change-case-all"] ?? {}).join(", ")}.`);
 }
 
+// src/objects-output.ts
+import {
+  GraphQLBoolean as GraphQLBoolean2,
+  GraphQLFloat as GraphQLFloat2,
+  GraphQLID as GraphQLID2,
+  GraphQLInt as GraphQLInt2,
+  GraphQLString as GraphQLString2,
+  getNamedType as getNamedType2,
+  isAbstractType as isAbstractType3,
+  isEnumType as isEnumType2,
+  isInterfaceType as isInterfaceType2,
+  isListType as isListType2,
+  isNonNullType as isNonNullType2,
+  isObjectType as isObjectType3,
+  isScalarType,
+  isUnionType
+} from "graphql";
+
+// src/cycles.ts
+import {
+  getNamedType,
+  isAbstractType,
+  isInputObjectType,
+  isInterfaceType,
+  isObjectType
+} from "graphql";
+function inputCycles(schema) {
+  return cycles(Object.values(schema.getTypeMap()).filter(isInputObjectType), (type) => isInputObjectType(type) ? Object.values(type.getFields()).map((field) => getNamedType(field.type)).filter(isInputObjectType) : []);
+}
+function outputCycles(schema) {
+  return cycles(Object.values(schema.getTypeMap()).filter((type) => isObjectType(type) && !type.name.startsWith("__")), (type) => {
+    if (isAbstractType(type))
+      return schema.getPossibleTypes(type);
+    if (!isObjectType(type) && !isInterfaceType(type))
+      return [];
+    return Object.values(type.getFields()).map((field) => getNamedType(field.type)).filter((named) => isObjectType(named) || isAbstractType(named));
+  });
+}
+function cycles(starts, next) {
+  const reaches = (from, target, seen) => next(from).some((named) => {
+    if (named.name === target)
+      return true;
+    if (seen.has(named.name))
+      return false;
+    seen.add(named.name);
+    return reaches(named, target, seen);
+  });
+  return new Set(starts.filter((start) => reaches(start, start.name, new Set)).map((start) => start.name));
+}
+
+// src/output-types.ts
+import {
+  GraphQLBoolean,
+  GraphQLFloat,
+  GraphQLID,
+  GraphQLInt,
+  GraphQLString,
+  isAbstractType as isAbstractType2,
+  isEnumType,
+  isListType,
+  isNonNullType,
+  isObjectType as isObjectType2
+} from "graphql";
+
+// src/source.ts
+function docComment(description, indent = "") {
+  if (!description)
+    return "";
+  const lines = description.replaceAll(`\r
+`, `
+`).replaceAll("*/", "*\\/").split(`
+`);
+  if (lines.length === 1)
+    return `${indent}/** ${lines[0]} */
+`;
+  return `${indent}/**
+${lines.map((line) => `${indent} * ${line}`.trimEnd()).join(`
+`)}
+${indent} */
+`;
+}
+function objectMembers(members) {
+  return members.map(([name, { code, lazy, description }]) => {
+    const doc = docComment(description, "\t");
+    return lazy ? `${doc}	get ${name}() {
+		return ${code};
+	},` : `${doc}	${name}: ${code},`;
+  }).join(`
+`);
+}
+function declare(typeName, naming, code, side, description) {
+  const schemaName = naming.schema(typeName);
+  const doc = docComment(description);
+  return `${doc}export const ${schemaName} = ${code};
+${doc}export type ${typeName} = z.${side}<typeof ${schemaName}>;`;
+}
+
+// src/output-types.ts
+var builtIns = {
+  [GraphQLString.name]: "string",
+  [GraphQLID.name]: "string",
+  [GraphQLInt.name]: "number",
+  [GraphQLFloat.name]: "number",
+  [GraphQLBoolean.name]: "boolean"
+};
+function declareCyclicObject(type, code, context) {
+  const types = new OutputTypeCode(context);
+  const output = context.naming.type(type.name);
+  const input = `${output}Wire`;
+  const doc = docComment(type.description);
+  return [
+    `${doc}export type ${output} = ${types.object(type, "output")};`,
+    `${doc}export type ${input} = ${types.object(type, "input")};`,
+    `${doc}export const ${context.naming.schema(output)}: z.ZodType<${output}, ${input}> = ${code};`
+  ].join(`
+`);
+}
+
+class OutputTypeCode {
+  #context;
+  constructor(context) {
+    this.#context = context;
+  }
+  object(type, side) {
+    const members = [
+      `	__typename?: ${JSON.stringify(type.name)} | undefined;`,
+      ...Object.values(type.getFields()).map((field) => `${docComment(field.description, "\t")}	${this.#member(field, side)};`)
+    ];
+    return `{
+${members.join(`
+`)}
+}`;
+  }
+  #member(field, side) {
+    const type = this.#required(field.type, side);
+    return isNonNullType(field.type) ? `${field.name}: ${type}` : `${field.name}?: ${type} | null | undefined`;
+  }
+  #required(type, side) {
+    if (isNonNullType(type))
+      return this.#required(type.ofType, side);
+    if (!isListType(type))
+      return this.#named(type, side);
+    const item = this.#required(type.ofType, side);
+    return isNonNullType(type.ofType) ? `Array<${item}>` : `Array<${item} | null | undefined>`;
+  }
+  #named(type, side) {
+    const { writer, naming, cyclic } = this.#context;
+    const builtIn = builtIns[type.name];
+    if (builtIn)
+      return builtIn;
+    if (isEnumType(type))
+      return `z.output<typeof ${writer.schemaName(type)}>`;
+    if (isAbstractType2(type))
+      return `z.${side}<typeof ${naming.schema(naming.type(type.name))}>`;
+    if (isObjectType2(type)) {
+      const name = naming.type(type.name);
+      if (cyclic.has(type.name))
+        return side === "output" ? name : `${name}Wire`;
+      return `z.${side}<typeof ${naming.schema(name)}>`;
+    }
+    return `z.${side}<typeof ${writer.scalarCode(type)}>`;
+  }
+}
+
+// src/objects-output.ts
+var builtIns2 = {
+  [GraphQLString2.name]: "z.string()",
+  [GraphQLID2.name]: "z.string()",
+  [GraphQLInt2.name]: "z.int32()",
+  [GraphQLFloat2.name]: "z.number()",
+  [GraphQLBoolean2.name]: "z.boolean()"
+};
+function objectBlocks(schema, writer, naming) {
+  const types = Object.values(schema.getTypeMap()).filter((type) => !type.name.startsWith("__"));
+  const context = { writer, naming, cyclic: outputCycles(schema) };
+  return [
+    ...types.filter(isObjectType3).map((type) => objectBlock(type, context)),
+    ...types.filter(isAbstractType3).map((type) => abstractBlock(schema, type, naming))
+  ];
+}
+function objectBlock(type, context) {
+  const { writer, naming } = context;
+  const typename = {
+    code: `z.literal(${JSON.stringify(type.name)}).optional()`,
+    lazy: false
+  };
+  const members = Object.values(type.getFields()).map((field) => [
+    field.name,
+    {
+      ...outputCode(field.type, writer, naming),
+      description: field.description
+    }
+  ]);
+  const code = `z.object({
+${objectMembers([["__typename", typename], ...members])}
+})`;
+  return context.cyclic.has(type.name) ? declareCyclicObject(type, code, context) : declare(naming.type(type.name), naming, code, "output", type.description);
+}
+function abstractBlock(schema, type, naming) {
+  const members = (isUnionType(type) ? type.getTypes() : schema.getPossibleTypes(type)).map((member) => naming.schema(naming.type(member.name)));
+  const code = members.length === 0 ? "z.never()" : members.length === 1 ? members[0] ?? "z.never()" : `z.union([${members.join(", ")}])`;
+  return declare(naming.type(type.name), naming, code, "output", type.description);
+}
+function outputCode(type, writer, naming) {
+  const named = getNamedType2(type);
+  const lazy = !isScalarType(named) && !isEnumType2(named);
+  return { code: nullable(type, writer, naming), lazy };
+}
+function nullable(type, writer, naming) {
+  if (isNonNullType2(type))
+    return required(type.ofType, writer, naming);
+  return `${required(type, writer, naming)}.nullish()`;
+}
+function required(type, writer, naming) {
+  if (isNonNullType2(type))
+    return required(type.ofType, writer, naming);
+  if (isListType2(type))
+    return `z.array(${nullable(type.ofType, writer, naming)})`;
+  if (isScalarType(type))
+    return builtIns2[type.name] ?? writer.scalarCode(type);
+  if (isEnumType2(type))
+    return writer.schemaName(type);
+  if (isObjectType3(type) || isInterfaceType2(type) || isUnionType(type))
+    return naming.schema(naming.type(type.name));
+  return "z.never()";
+}
+
+// src/results-output.ts
+import {
+  isCompositeType,
+  Kind as Kind2
+} from "graphql";
+
+// src/results-selections.ts
+import {
+  isEnumType as isEnumType3,
+  isListType as isListType3,
+  isNonNullType as isNonNullType3,
+  isObjectType as isObjectType4,
+  isScalarType as isScalarType2
+} from "graphql";
+
+// src/collect-fields.ts
+import {
+  isAbstractType as isAbstractType4,
+  Kind
+} from "graphql";
+var conditions = new Set(["skip", "include", "defer"]);
+function collectFields(schema, fragments, type, sets) {
+  const fields = new Map;
+  const applies = (condition) => {
+    const named = schema.getType(condition);
+    if (!named)
+      return false;
+    if (named.name === type.name)
+      return true;
+    return isAbstractType4(named) && schema.isSubType(named, type);
+  };
+  const visit = (set, optional, seen) => {
+    for (const selection of set.selections) {
+      const conditional = optional || isConditional(selection);
+      if (selection.kind === Kind.FIELD) {
+        const key = selection.alias?.value ?? selection.name.value;
+        const entry = { node: selection, conditional };
+        const field = fields.get(key);
+        if (field) {
+          field.nodes.push(entry);
+          field.optional &&= conditional;
+        } else
+          fields.set(key, {
+            name: selection.name.value,
+            nodes: [entry],
+            optional: conditional
+          });
+      } else if (selection.kind === Kind.INLINE_FRAGMENT) {
+        const condition = selection.typeCondition?.name.value;
+        if (!condition || applies(condition))
+          visit(selection.selectionSet, conditional, seen);
+      } else {
+        const name = selection.name.value;
+        const fragment = fragments.get(name);
+        if (fragment && !seen.has(name) && applies(fragment.typeCondition.name.value))
+          visit(fragment.selectionSet, conditional, new Set([...seen, name]));
+      }
+    }
+  };
+  for (const { set, conditional } of sets)
+    visit(set, conditional, new Set);
+  return fields;
+}
+function isConditional(selection) {
+  return (selection.directives ?? []).some((directive) => conditions.has(directive.name.value));
+}
+
+// src/results-selections.ts
+var failure = "@nxgt/graphql-codegen-zod:";
+var typename = "\x00typename\x00";
+var hoistDepth = 5;
+
+class Selections {
+  #schema;
+  #fragments;
+  #writer;
+  #hoisted = new Map;
+  #prefix = "";
+  constructor(schema, fragments, writer) {
+    this.#schema = schema;
+    this.#fragments = fragments;
+    this.#writer = writer;
+  }
+  declare(name, type, sets, path) {
+    this.#hoisted = new Map;
+    this.#prefix = name;
+    const code = this.#code(type, sets, [path], "", 0);
+    return {
+      hoisted: [...this.#hoisted].map(([body, hoisted]) => `const ${hoisted}$ = ${body};
+const ${hoisted}: z.ZodType<z.output<typeof ${hoisted}$>, z.input<typeof ${hoisted}$>> = ${hoisted}$;`),
+      code
+    };
+  }
+  #code(type, sets, path, indent, depth) {
+    if (depth >= hoistDepth) {
+      const body = this.#code(type, sets, path, "", 0);
+      const known = this.#hoisted.get(body);
+      if (known)
+        return known;
+      const name = `${this.#prefix}$${this.#hoisted.size + 1}`;
+      this.#hoisted.set(body, name);
+      return name;
+    }
+    if (isObjectType4(type))
+      return this.#object(type, sets, path, indent, depth).replaceAll(typename, `z.literal(${JSON.stringify(type.name)})`);
+    return this.#abstract(type, sets, path, indent, depth);
+  }
+  #abstract(type, sets, path, indent, depth) {
+    const members = this.#schema.getPossibleTypes(type);
+    if (members.length === 0)
+      return "z.never()";
+    const inner = `${indent}	`;
+    const groups = new Map;
+    const keys = new Map;
+    for (const member of members) {
+      const code = this.#object(member, sets, path, inner, depth);
+      groups.set(code, [...groups.get(code) ?? [], member]);
+      keys.set(member.name, [...collectFields(this.#schema, this.#fragments, member, sets)].filter(([, field]) => field.name === "__typename" && !field.optional).map(([key]) => key));
+    }
+    const fill = (code, group) => {
+      const names = group.map((member) => JSON.stringify(member.name));
+      return code.replaceAll(typename, names.length === 1 ? `z.literal(${names[0]})` : `z.enum([${names.join(", ")}])`);
+    };
+    const all = [...groups];
+    if (all.length === 1) {
+      const [code = "", group = []] = all[0] ?? [];
+      return fill(code.replaceAll(`
+${inner}`, `
+${indent}`), group);
+    }
+    const discriminator = this.#discriminator(type.name, keys, path);
+    return `z.discriminatedUnion(${JSON.stringify(discriminator)}, [
+${all.map(([code, group]) => `${inner}${fill(code, group)},`).join(`
+`)}
+${indent}])`;
+  }
+  #discriminator(type, keys, path) {
+    for (const [member, selected] of keys)
+      if (selected.length === 0)
+        throw new Error(`${failure} ${path.join(".")} selects the abstract type ${type} without __typename for ${member}. Select __typename there, so the result tells its members apart.`);
+    const lists = [...keys.values()];
+    const shared = (lists[0] ?? []).filter((key) => lists.every((selected) => selected.includes(key)));
+    const key = shared.includes("__typename") ? "__typename" : shared[0];
+    if (key === undefined)
+      throw new Error(`${failure} ${path.join(".")} selects __typename under a different key for each member of ${type} (${[...new Set(lists.flat())].join(", ")}). Select it under one key for every member, so the result tells its members apart.`);
+    return key;
+  }
+  #object(type, sets, path, indent, depth) {
+    const inner = `${indent}	`;
+    const members = [
+      ...collectFields(this.#schema, this.#fragments, type, sets)
+    ].map(([key, field]) => {
+      const code = this.#field(type, field, [...path, key], inner, depth);
+      return `${inner}${key}: ${field.optional ? `${code}.optional()` : code},`;
+    });
+    return members.length === 0 ? "z.object({})" : `z.object({
+${members.join(`
+`)}
+${indent}})`;
+  }
+  #field(parent, field, path, indent, depth) {
+    if (field.name === "__typename")
+      return typename;
+    const definition = parent.getFields()[field.name];
+    if (!definition)
+      return "z.unknown()";
+    const implied = field.optional && field.nodes.length === 1;
+    const sets = field.nodes.flatMap(({ node, conditional }) => node.selectionSet ? [{ set: node.selectionSet, conditional: conditional && !implied }] : []);
+    return this.#nullable(definition.type, sets, path, indent, depth + 1);
+  }
+  #nullable(type, sets, path, indent, depth) {
+    if (isNonNullType3(type))
+      return this.#required(type.ofType, sets, path, indent, depth);
+    return `${this.#required(type, sets, path, indent, depth)}.nullable()`;
+  }
+  #required(type, sets, path, indent, depth) {
+    if (isNonNullType3(type))
+      return this.#required(type.ofType, sets, path, indent, depth);
+    if (isListType3(type))
+      return `z.array(${this.#nullable(type.ofType, sets, path, indent, depth)})`;
+    if (isScalarType2(type))
+      return builtIns2[type.name] ?? this.#writer.scalarCode(type);
+    if (isEnumType3(type))
+      return this.#writer.schemaName(type);
+    return this.#code(type, sets, path, indent, depth);
+  }
+}
+
+// src/results-output.ts
+function resultsBlocks(schema, documents, writer, naming) {
+  const definitions = documents.flatMap((file) => file.document?.definitions ?? []);
+  const fragments = new Map(definitions.filter((node) => node.kind === Kind2.FRAGMENT_DEFINITION).map((node) => [node.name.value, node]));
+  const selections = new Selections(schema, fragments, writer);
+  const block = (typeName, written) => [
+    ...written.hoisted,
+    declare(typeName, naming, written.code, "output")
+  ].join(`
+`);
+  return [
+    ...[...fragments.values()].flatMap((fragment) => {
+      const type = schema.getType(fragment.typeCondition.name.value);
+      if (!isCompositeType(type))
+        return [];
+      const typeName = naming.fragment(fragment.name.value);
+      const set = { set: fragment.selectionSet, conditional: false };
+      return [
+        block(typeName, selections.declare(naming.schema(typeName), type, [set], `fragment ${fragment.name.value}`))
+      ];
+    }),
+    ...definitions.filter((node) => node.kind === Kind2.OPERATION_DEFINITION).flatMap((operation) => {
+      const name = operation.name?.value;
+      const root = schema.getRootType(operation.operation);
+      if (!name || !root)
+        return [];
+      const typeName = naming.result(name, operation.operation);
+      const set = { set: operation.selectionSet, conditional: false };
+      return [
+        block(typeName, selections.declare(naming.schema(typeName), root, [set], name))
+      ];
+    })
+  ];
+}
+
 // src/scalars.ts
 import { createRequire } from "node:module";
 import { dirname, resolve } from "node:path";
@@ -180,55 +638,25 @@ async function recordKeys(module, outputFile) {
 // src/schema-output.ts
 import { constraintsOn } from "@nxgt/graphql-validation/codegen";
 import {
-  isEnumType as isEnumType2,
+  isEnumType as isEnumType5,
   isInputObjectType as isInputObjectType4,
-  isInterfaceType,
-  isObjectType
+  isInterfaceType as isInterfaceType3,
+  isObjectType as isObjectType5
 } from "graphql";
 
-// src/cycles.ts
-import {
-  getNamedType,
-  isInputObjectType
-} from "graphql";
-function inputCycles(schema) {
-  const inputs = Object.values(schema.getTypeMap()).filter(isInputObjectType);
-  const cyclic = new Set;
-  for (const start of inputs) {
-    if (reaches(start, start.name, new Set))
-      cyclic.add(start.name);
-  }
-  return cyclic;
-}
-function reaches(from, target, seen) {
-  for (const field of Object.values(from.getFields())) {
-    const named = getNamedType(field.type);
-    if (!isInputObjectType(named))
-      continue;
-    if (named.name === target)
-      return true;
-    if (seen.has(named.name))
-      continue;
-    seen.add(named.name);
-    if (reaches(named, target, seen))
-      return true;
-  }
-  return false;
-}
-
 // src/defaults.ts
 import * as graphql from "graphql";
 import {
   astFromValue,
-  GraphQLID,
-  getNamedType as getNamedType2,
+  GraphQLID as GraphQLID3,
+  getNamedType as getNamedType3,
   getNullableType,
   isInputObjectType as isInputObjectType2,
-  isListType,
-  isNonNullType,
-  isScalarType,
+  isListType as isListType4,
+  isNonNullType as isNonNullType4,
+  isScalarType as isScalarType3,
   isSpecifiedScalarType,
-  Kind,
+  Kind as Kind3,
   valueFromASTUntyped
 } from "graphql";
 function parsedDefault(literal, type, where) {
@@ -237,14 +665,14 @@ function parsedDefault(literal, type, where) {
 }
 function assertExact(literal, type, where) {
   const nullable = getNullableType(type);
-  if (isListType(nullable)) {
-    const items = literal.kind === Kind.LIST ? literal.values : [literal];
+  if (isListType4(nullable)) {
+    const items = literal.kind === Kind3.LIST ? literal.values : [literal];
     for (const item of items)
       assertExact(item, nullable.ofType, where);
     return;
   }
   if (isInputObjectType2(nullable)) {
-    if (literal.kind !== Kind.OBJECT)
+    if (literal.kind !== Kind3.OBJECT)
       return;
     const fields = nullable.getFields();
     for (const field of literal.fields) {
@@ -254,8 +682,8 @@ function assertExact(literal, type, where) {
     }
     return;
   }
-  const keeps = nullable === GraphQLID || isScalarType(nullable) && !isSpecifiedScalarType(nullable);
-  if (keeps && literal.kind === Kind.INT && !Number.isSafeInteger(Number(literal.value)))
+  const keeps = nullable === GraphQLID3 || isScalarType3(nullable) && !isSpecifiedScalarType(nullable);
+  if (keeps && literal.kind === Kind3.INT && !Number.isSafeInteger(Number(literal.value)))
     throw new Error(`@nxgt/graphql-codegen-zod: the default of ${where} holds ${literal.value}, which a JavaScript number cannot keep exact. Write it as a string, if its scalar takes one.`);
 }
 function defaultLiteral(input) {
@@ -275,10 +703,10 @@ function defaultLiteral(input) {
   return astFromValue(loose.defaultValue, input.type) ?? undefined;
 }
 function coerced(value, type) {
-  const nullable = isNonNullType(type) ? type.ofType : type;
+  const nullable = isNonNullType4(type) ? type.ofType : type;
   if (value === null || value === undefined)
     return value;
-  if (isListType(nullable)) {
+  if (isListType4(nullable)) {
     const items = Array.isArray(value) ? value : [value];
     return items.map((item) => coerced(item, nullable.ofType));
   }
@@ -289,63 +717,30 @@ function coerced(value, type) {
       return [key, definition ? coerced(field, definition.type) : field];
     }));
   }
-  if (getNamedType2(nullable) === GraphQLID && typeof value === "number")
+  if (getNamedType3(nullable) === GraphQLID3 && typeof value === "number")
     return String(value);
   return value;
 }
 
-// src/source.ts
-function docComment(description, indent = "") {
-  if (!description)
-    return "";
-  const lines = description.replaceAll(`\r
-`, `
-`).replaceAll("*/", "*\\/").split(`
-`);
-  if (lines.length === 1)
-    return `${indent}/** ${lines[0]} */
-`;
-  return `${indent}/**
-${lines.map((line) => `${indent} * ${line}`.trimEnd()).join(`
-`)}
-${indent} */
-`;
-}
-function objectMembers(members) {
-  return members.map(([name, { code, lazy, description }]) => {
-    const doc = docComment(description, "\t");
-    return lazy ? `${doc}	get ${name}() {
-		return ${code};
-	},` : `${doc}	${name}: ${code},`;
-  }).join(`
-`);
-}
-function declare(typeName, naming, code, side, description) {
-  const schemaName = naming.schema(typeName);
-  const doc = docComment(description);
-  return `${doc}export const ${schemaName} = ${code};
-${doc}export type ${typeName} = z.${side}<typeof ${schemaName}>;`;
-}
-
 // src/type-code.ts
 import {
-  GraphQLBoolean,
-  GraphQLFloat,
-  GraphQLID as GraphQLID2,
-  GraphQLInt,
-  GraphQLString,
-  getNamedType as getNamedType3,
-  isEnumType,
+  GraphQLBoolean as GraphQLBoolean3,
+  GraphQLFloat as GraphQLFloat3,
+  GraphQLID as GraphQLID4,
+  GraphQLInt as GraphQLInt3,
+  GraphQLString as GraphQLString3,
+  getNamedType as getNamedType4,
+  isEnumType as isEnumType4,
   isInputObjectType as isInputObjectType3,
-  isListType as isListType2,
-  isNonNullType as isNonNullType2
+  isListType as isListType5,
+  isNonNullType as isNonNullType5
 } from "graphql";
-var builtIns = {
-  [GraphQLString.name]: "string",
-  [GraphQLID2.name]: "string",
-  [GraphQLInt.name]: "number",
-  [GraphQLFloat.name]: "number",
-  [GraphQLBoolean.name]: "boolean"
+var builtIns3 = {
+  [GraphQLString3.name]: "string",
+  [GraphQLID4.name]: "string",
+  [GraphQLInt3.name]: "number",
+  [GraphQLFloat3.name]: "number",
+  [GraphQLBoolean3.name]: "boolean"
 };
 function declareCyclic(type, code, writer, naming, cyclic) {
   const types = new TypeCode(writer, naming, cyclic);
@@ -380,7 +775,7 @@ ${members.join(`
 }`;
   }
   #member(field, side) {
-    const nullable = !isNonNullType2(field.type);
+    const nullable = !isNonNullType5(field.type);
     const filled = defaultLiteral(field) !== undefined;
     const type = this.#required(field.type, side);
     if (!nullable)
@@ -390,19 +785,19 @@ ${members.join(`
     return `${field.name}?: ${type} | null | undefined`;
   }
   #required(type, side) {
-    if (isNonNullType2(type))
+    if (isNonNullType5(type))
       return this.#required(type.ofType, side);
-    if (!isListType2(type))
+    if (!isListType5(type))
       return this.#named(type, side);
-    const item = isNonNullType2(type.ofType) ? this.#required(type.ofType, side) : `${this.#required(type.ofType, side)} | null | undefined`;
+    const item = isNonNullType5(type.ofType) ? this.#required(type.ofType, side) : `${this.#required(type.ofType, side)} | null | undefined`;
     const list = `Array<${item}>`;
-    return side === "input" ? `${this.#named(getNamedType3(type), side)} | ${list}` : list;
+    return side === "input" ? `${this.#named(getNamedType4(type), side)} | ${list}` : list;
   }
   #named(type, side) {
-    const builtIn = builtIns[type.name];
+    const builtIn = builtIns3[type.name];
     if (builtIn)
       return builtIn;
-    if (isEnumType(type))
+    if (isEnumType4(type))
       return `z.output<typeof ${this.#writer.schemaName(type)}>`;
     if (isInputObjectType3(type)) {
       const name = this.#naming.type(type.name);
@@ -419,10 +814,10 @@ function schemaBlocks(schema, writer, naming) {
   const types = Object.values(schema.getTypeMap()).filter((type) => !type.name.startsWith("__"));
   const cyclic = inputCycles(schema);
   return [
-    ...types.filter(isEnumType2).map((type) => enumBlock(type, naming)),
+    ...types.filter(isEnumType5).map((type) => enumBlock(type, naming)),
     ...types.filter(isInputObjectType4).map((type) => inputBlock(type, writer, naming, cyclic)),
     ...types.flatMap((type) => {
-      if (!isObjectType(type) && !isInterfaceType(type))
+      if (!isObjectType5(type) && !isInterfaceType3(type))
         return [];
       return Object.values(type.getFields()).filter((field) => field.args.length > 0).map((field) => {
         const name = naming.args(type.name, field.name);
@@ -489,11 +884,11 @@ import {
   constraintsOn as constraintsOn2
 } from "@nxgt/graphql-validation/codegen";
 import {
-  getNamedType as getNamedType4,
+  getNamedType as getNamedType5,
   isInputObjectType as isInputObjectType5,
-  isListType as isListType3,
-  isNonNullType as isNonNullType3,
-  Kind as Kind2,
+  isListType as isListType6,
+  isNonNullType as isNonNullType6,
+  Kind as Kind4,
   TypeInfo,
   typeFromAST,
   visit,
@@ -501,8 +896,8 @@ import {
 } from "graphql";
 function variablesBlocks(schema, documents, writer, naming) {
   const definitions = documents.flatMap((file) => file.document?.definitions ?? []);
-  const fragments = new Map(definitions.filter((node) => node.kind === Kind2.FRAGMENT_DEFINITION).map((node) => [node.name.value, node]));
-  return definitions.filter((node) => node.kind === Kind2.OPERATION_DEFINITION).flatMap((operation) => {
+  const fragments = new Map(definitions.filter((node) => node.kind === Kind4.FRAGMENT_DEFINITION).map((node) => [node.name.value, node]));
+  return definitions.filter((node) => node.kind === Kind4.OPERATION_DEFINITION).flatMap((operation) => {
     const operationName = operation.name?.value;
     if (!operationName)
       return [];
@@ -558,7 +953,7 @@ function usages(schema, directive, operation, fragments) {
   return walk.found;
 }
 function walkValue(walk, value, type, constraints, where) {
-  if (value.kind === Kind2.VARIABLE) {
+  if (value.kind === Kind4.VARIABLE) {
     if (!walk.variables.has(value.name.value))
       return;
     const list = walk.found.get(value.name.value) ?? [];
@@ -566,15 +961,15 @@ function walkValue(walk, value, type, constraints, where) {
     walk.found.set(value.name.value, list);
     return;
   }
-  const nullable = isNonNullType3(type) ? type.ofType : type;
-  if (value.kind === Kind2.LIST && isListType3(nullable)) {
+  const nullable = isNonNullType6(type) ? type.ofType : type;
+  if (value.kind === Kind4.LIST && isListType6(nullable)) {
     const items = constraints.filter(({ rule }) => rule.target !== "list");
     for (const item of value.values)
       walkValue(walk, item, nullable.ofType, items, where);
     return;
   }
-  const named = getNamedType4(type);
-  if (value.kind === Kind2.OBJECT && isInputObjectType5(named)) {
+  const named = getNamedType5(type);
+  if (value.kind === Kind4.OBJECT && isInputObjectType5(named)) {
     for (const field of value.fields) {
       const definition = named.getFields()[field.name.value];
       if (definition) {
@@ -606,11 +1001,11 @@ import {
 } from "@nxgt/graphql-validation/codegen";
 import {
   GraphQLNonNull,
-  getNamedType as getNamedType5,
-  isEnumType as isEnumType3,
+  getNamedType as getNamedType6,
+  isEnumType as isEnumType6,
   isInputObjectType as isInputObjectType6,
-  isNonNullType as isNonNullType4,
-  isScalarType as isScalarType2,
+  isNonNullType as isNonNullType7,
+  isScalarType as isScalarType4,
   isSpecifiedScalarType as isSpecifiedScalarType2
 } from "graphql";
 class Writer {
@@ -635,7 +1030,7 @@ class Writer {
         lazy = true;
         return this.schemaName(named);
       }
-      if (isEnumType3(named))
+      if (isEnumType6(named))
         return this.schemaName(named);
       return this.#scalars.code(named);
     };
@@ -646,7 +1041,7 @@ class Writer {
         }),
         lazy
       };
-    const nullable = !isNonNullType4(type);
+    const nullable = !isNonNullType7(type);
     const required = inputCode2(nullable ? new GraphQLNonNull(type) : type, constraints, where, named, { list: singleOrList });
     const value = JSON.stringify(parsedDefault(defaultValue, type, where));
     return {
@@ -655,7 +1050,7 @@ class Writer {
     };
   }
   required(type, constraints, where) {
-    return this.value(isNonNullType4(type) ? type : new GraphQLNonNull(type), constraints, where);
+    return this.value(isNonNullType7(type) ? type : new GraphQLNonNull(type), constraints, where);
   }
 }
 var singleOrList = ({
@@ -663,8 +1058,8 @@ var singleOrList = ({
   code,
   single
 }) => {
-  const named = getNamedType5(type);
-  const transforms = isInputObjectType6(named) || isScalarType2(named) && !isSpecifiedScalarType2(named);
+  const named = getNamedType6(type);
+  const transforms = isInputObjectType6(named) || isScalarType4(named) && !isSpecifiedScalarType2(named);
   const first = transforms ? `z.custom<z.input<typeof ${single}>>((value) => value != null && !Array.isArray(value))` : single;
   return `z.union([${code}, ${first}.transform((value): unknown[] => [value]).pipe(${code})])`;
 };
@@ -680,13 +1075,15 @@ async function plugin(schema, documents, config = {}, info) {
     const writer = new Writer(directive, naming, scalars);
     return [
       ...schemaBlocks(schema, writer, naming),
-      ...variablesBlocks(schema, documents, writer, naming)
+      ...config.objects === false ? [] : objectBlocks(schema, writer, naming),
+      ...variablesBlocks(schema, documents, writer, naming),
+      ...config.operations === false ? [] : resultsBlocks(schema, documents, writer, naming)
     ];
   };
-  const declarations = (await write(new Imports)).flatMap((block) => [...block.matchAll(/^export (const|type) (\w+)/gm)].map((m) => `${m[1]} ${m[2]}`));
+  const declarations = (await write(new Imports)).flatMap((block) => [...block.matchAll(/^(?:export )?(const|type) ([\w$]+)/gm)].map((m) => `${m[1]} ${m[2]}`));
   const twice = declarations.find((declaration, index) => declarations.indexOf(declaration) !== index);
   if (twice)
-    throw new Error(`@nxgt/graphql-codegen-zod: the file would declare ${twice.split(" ")[1]} twice: two GraphQL names, or an input type in a cycle and its Input type, give the same name. Rename one of the GraphQL types, or set typesSuffix.`);
+    throw new Error(`@nxgt/graphql-codegen-zod: the file would declare ${twice.split(" ")[1]} twice: two GraphQL names, or a type in a cycle and its Input or Wire type, give the same name. Rename one of the GraphQL types or operations, set typesSuffix, or set objects: false or operations: false.`);
   const declared = declarations.map((declaration) => declaration.split(" ")[1] ?? "");
   const imports = new Imports(declared);
   const blocks = await write(imports);
@@ -702,7 +1099,7 @@ function assertSdl(schema) {
   for (const type of Object.values(schema.getTypeMap())) {
     if (type.name.startsWith("__"))
       continue;
-    const inputs = isInputObjectType7(type) ? Object.values(type.getFields()) : isObjectType2(type) || isInterfaceType2(type) ? Object.values(type.getFields()).flatMap((field) => field.args) : [];
+    const inputs = isInputObjectType7(type) ? Object.values(type.getFields()) : isObjectType6(type) || isInterfaceType4(type) ? Object.values(type.getFields()).flatMap((field) => field.args) : [];
     const bare = inputs.find((input) => !input.astNode);
     if (bare) {
       throw new Error(`@nxgt/graphql-codegen-zod: the schema declares @constraint, but ${type.name} has no SDL to read it from (an introspected schema?). Point codegen's schema at the SDL files.`);
@@ -713,5 +1110,5 @@ export {
   plugin
 };
 
-//# debugId=AA4EFD5F1FAF8A9864756E2164756E21
+//# debugId=7FB3A417D01910B464756E2164756E21
 //# sourceMappingURL=index.js.map