@nxgt/graphql-codegen-zod 0.0.0-stage → 0.2.0

package/dist/index.js

@@ -0,0 +1,1114 @@
+// src/index.ts
+import { checkConstraints } from "@nxgt/graphql-validation/codegen";
+import {
+  isInputObjectType as isInputObjectType7,
+  isInterfaceType as isInterfaceType4,
+  isObjectType as isObjectType6
+} from "graphql";
+
+// src/imports.ts
+class Imports {
+  #byModule = new Map([
+    ["zod", new Map([["z", "z"]])]
+  ]);
+  #taken;
+  constructor(reserved = []) {
+    this.#taken = new Set(["z", ...reserved]);
+  }
+  add(module, exported) {
+    const names = this.#byModule.get(module) ?? new Map;
+    this.#byModule.set(module, names);
+    const known = names.get(exported);
+    if (known)
+      return known;
+    let local = exported;
+    for (let n = 2;this.#taken.has(local); n++)
+      local = `${exported}${n}`;
+    this.#taken.add(local);
+    names.set(exported, local);
+    return local;
+  }
+  lines() {
+    return [...this.#byModule].map(([module, names]) => `import { ${[...names].map(([exported, local]) => exported === local ? local : `${exported} as ${local}`).join(", ")} } from ${JSON.stringify(module)};`);
+  }
+}
+
+// src/naming.ts
+import * as changeCase from "change-case";
+
+class Naming {
+  #config;
+  #convert;
+  constructor(config) {
+    this.#config = config;
+    this.#convert = converter(config.namingConvention);
+  }
+  type(name) {
+    return this.#wrap(this.#convert(name));
+  }
+  args(parent, field) {
+    const underscore = this.#config.addUnderscoreToArgsType ? "_" : "";
+    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;
+    return omitOperationSuffix || dedupeOperationSuffix && operation.toLowerCase().endsWith(type.toLowerCase()) ? "" : type;
+  }
+  schema(type) {
+    return `${this.#config.schemaPrefix ?? "z"}${type}`;
+  }
+  #wrap(name) {
+    return `${this.#config.typesPrefix ?? ""}${name}${this.#config.typesSuffix ?? ""}`;
+  }
+}
+var lowerCaseFirst = (name) => name.charAt(0).toLowerCase() + name.slice(1);
+var upperCaseFirst = (name) => name.charAt(0).toUpperCase() + name.slice(1);
+var cases = {
+  "change-case-all": {
+    camelCase: changeCase.camelCase,
+    capitalCase: changeCase.capitalCase,
+    constantCase: changeCase.constantCase,
+    dotCase: changeCase.dotCase,
+    headerCase: changeCase.trainCase,
+    noCase: changeCase.noCase,
+    paramCase: changeCase.kebabCase,
+    pascalCase: changeCase.pascalCase,
+    pathCase: changeCase.pathCase,
+    sentenceCase: changeCase.sentenceCase,
+    snakeCase: changeCase.snakeCase,
+    lowerCase: (name) => name.toLowerCase(),
+    upperCase: (name) => name.toUpperCase(),
+    lowerCaseFirst,
+    upperCaseFirst
+  },
+  "change-case": {
+    camelCase: changeCase.camelCase,
+    capitalCase: changeCase.capitalCase,
+    constantCase: changeCase.constantCase,
+    dotCase: changeCase.dotCase,
+    kebabCase: changeCase.kebabCase,
+    noCase: changeCase.noCase,
+    pascalCase: changeCase.pascalCase,
+    pascalSnakeCase: changeCase.pascalSnakeCase,
+    pathCase: changeCase.pathCase,
+    sentenceCase: changeCase.sentenceCase,
+    snakeCase: changeCase.snakeCase,
+    trainCase: changeCase.trainCase
+  }
+};
+var byPart = (fn, transformUnderscore) => (name) => transformUnderscore ? fn(name) : name.split("_").map(fn).join("_");
+function converter(convention) {
+  if (convention === undefined)
+    return byPart(changeCase.pascalCase, false);
+  if (convention === "keep")
+    return (name) => name;
+  if (typeof convention === "function")
+    return byPart(convention, false);
+  if (typeof convention === "string")
+    return byPart(caseNamed(convention), false);
+  const { typeNames, transformUnderscore } = convention;
+  if (typeNames === "keep")
+    return (name) => name;
+  if (typeNames === undefined)
+    return byPart(changeCase.pascalCase, transformUnderscore ?? false);
+  const fn = typeof typeNames === "function" ? typeNames : caseNamed(typeNames);
+  return byPart(fn, true);
+}
+function caseNamed(spec) {
+  const [module = "", name = ""] = spec.split("#");
+  const fn = cases[module]?.[name];
+  if (fn)
+    return fn;
+  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";
+import { pathToFileURL } from "node:url";
+
+class ScalarSources {
+  #config;
+  #imports;
+  #recordKeys;
+  constructor(config, imports, recordKeys) {
+    this.#config = config;
+    this.#imports = imports;
+    this.#recordKeys = recordKeys;
+  }
+  static async load(config, imports, outputFile) {
+    if (!config.scalarSchemas)
+      return new ScalarSources(config, imports, undefined);
+    const keys = await recordKeys(config.scalarSchemas, outputFile);
+    return new ScalarSources(config, imports, keys);
+  }
+  code(type) {
+    const own = this.#config.zodScalars?.[type.name];
+    if (own !== undefined) {
+      const at = own.lastIndexOf("#");
+      if (at <= 0 || at === own.length - 1) {
+        throw new Error(`@nxgt/graphql-codegen-zod: zodScalars.${type.name} is "${own}"; write it '<module>#<export>', e.g. './money#moneySchema'.`);
+      }
+      return this.#imports.add(own.slice(0, at), own.slice(at + 1));
+    }
+    const record = this.#config.scalarSchemas;
+    if (record && (!this.#recordKeys || this.#recordKeys.has(type.name))) {
+      return `${this.#imports.add(record, "scalarSchemas")}.${type.name}`;
+    }
+    const where = record ? `neither in zodScalars nor in ${record}'s scalarSchemas` : "not in zodScalars, and no scalarSchemas is set";
+    throw new Error(`@nxgt/graphql-codegen-zod: the scalar ${type.name} is ${where}. Map it: zodScalars: { ${type.name}: './module#export' }, or set scalarSchemas: '@nxgt/graphql-scalars'.`);
+  }
+}
+async function recordKeys(module, outputFile) {
+  try {
+    const base = module.startsWith(".") ? resolve(dirname(resolve(outputFile ?? "index.ts")), module) : createRequire(resolve("package.json")).resolve(module);
+    const loaded = await import(pathToFileURL(base).href);
+    const record = loaded.scalarSchemas;
+    if (typeof record !== "object" || record === null) {
+      throw new Error(`@nxgt/graphql-codegen-zod: ${module} exports no scalarSchemas record.`);
+    }
+    return new Set(Object.keys(record));
+  } catch (error) {
+    if (error instanceof Error && error.message.startsWith("@nxgt/graphql-codegen-zod:"))
+      throw error;
+    return;
+  }
+}
+
+// src/schema-output.ts
+import { constraintsOn } from "@nxgt/graphql-validation/codegen";
+import {
+  isEnumType as isEnumType5,
+  isInputObjectType as isInputObjectType4,
+  isInterfaceType as isInterfaceType3,
+  isObjectType as isObjectType5
+} from "graphql";
+
+// src/defaults.ts
+import * as graphql from "graphql";
+import {
+  astFromValue,
+  GraphQLID as GraphQLID3,
+  getNamedType as getNamedType3,
+  getNullableType,
+  isInputObjectType as isInputObjectType2,
+  isListType as isListType4,
+  isNonNullType as isNonNullType4,
+  isScalarType as isScalarType3,
+  isSpecifiedScalarType,
+  Kind as Kind3,
+  valueFromASTUntyped
+} from "graphql";
+function parsedDefault(literal, type, where) {
+  assertExact(literal, type, where);
+  return coerced(valueFromASTUntyped(literal), type);
+}
+function assertExact(literal, type, where) {
+  const nullable = getNullableType(type);
+  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 !== Kind3.OBJECT)
+      return;
+    const fields = nullable.getFields();
+    for (const field of literal.fields) {
+      const definition = fields[field.name.value];
+      if (definition)
+        assertExact(field.value, definition.type, where);
+    }
+    return;
+  }
+  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) {
+  if (input.astNode)
+    return input.astNode.defaultValue;
+  const loose = input;
+  if (loose.default?.literal)
+    return loose.default.literal;
+  if (loose.default) {
+    const toLiteral = graphql.valueToLiteral;
+    if (loose.default.value === undefined || !toLiteral)
+      return;
+    return toLiteral(loose.default.value, input.type);
+  }
+  if (loose.defaultValue === undefined)
+    return;
+  return astFromValue(loose.defaultValue, input.type) ?? undefined;
+}
+function coerced(value, type) {
+  const nullable = isNonNullType4(type) ? type.ofType : type;
+  if (value === null || value === undefined)
+    return value;
+  if (isListType4(nullable)) {
+    const items = Array.isArray(value) ? value : [value];
+    return items.map((item) => coerced(item, nullable.ofType));
+  }
+  if (isInputObjectType2(nullable) && typeof value === "object") {
+    const fields = nullable.getFields();
+    return Object.fromEntries(Object.entries(value).map(([key, field]) => {
+      const definition = fields[key];
+      return [key, definition ? coerced(field, definition.type) : field];
+    }));
+  }
+  if (getNamedType3(nullable) === GraphQLID3 && typeof value === "number")
+    return String(value);
+  return value;
+}
+
+// src/type-code.ts
+import {
+  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 isListType5,
+  isNonNullType as isNonNullType5
+} from "graphql";
+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);
+  const output = naming.type(type.name);
+  const input = `${output}Input`;
+  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 ${naming.schema(output)}: z.ZodType<${output}, ${input}> = ${code};`
+  ].join(`
+`);
+}
+
+class TypeCode {
+  #writer;
+  #naming;
+  #cyclic;
+  constructor(writer, naming, cyclic) {
+    this.#writer = writer;
+    this.#naming = naming;
+    this.#cyclic = cyclic;
+  }
+  object(type, side) {
+    const fields = Object.values(type.getFields());
+    if (type.isOneOf)
+      return fields.map((field) => `{ ${field.name}: ${this.#required(field.type, side)} }`).join(" | ");
+    const members = fields.map((field) => `${docComment(field.description, "\t")}	${this.#member(field, side)};`);
+    return `{
+${members.join(`
+`)}
+}`;
+  }
+  #member(field, side) {
+    const nullable = !isNonNullType5(field.type);
+    const filled = defaultLiteral(field) !== undefined;
+    const type = this.#required(field.type, side);
+    if (!nullable)
+      return side === "input" && filled ? `${field.name}?: ${type} | undefined` : `${field.name}: ${type}`;
+    if (side === "output" && filled)
+      return `${field.name}: ${type} | null`;
+    return `${field.name}?: ${type} | null | undefined`;
+  }
+  #required(type, side) {
+    if (isNonNullType5(type))
+      return this.#required(type.ofType, side);
+    if (!isListType5(type))
+      return this.#named(type, side);
+    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(getNamedType4(type), side)} | ${list}` : list;
+  }
+  #named(type, side) {
+    const builtIn = builtIns3[type.name];
+    if (builtIn)
+      return builtIn;
+    if (isEnumType4(type))
+      return `z.output<typeof ${this.#writer.schemaName(type)}>`;
+    if (isInputObjectType3(type)) {
+      const name = this.#naming.type(type.name);
+      if (this.#cyclic.has(type.name))
+        return side === "output" ? name : `${name}Input`;
+      return `z.${side}<typeof ${this.#writer.schemaName(type)}>`;
+    }
+    return `z.${side}<typeof ${this.#writer.scalarCode(type)}>`;
+  }
+}
+
+// src/schema-output.ts
+function schemaBlocks(schema, writer, naming) {
+  const types = Object.values(schema.getTypeMap()).filter((type) => !type.name.startsWith("__"));
+  const cyclic = inputCycles(schema);
+  return [
+    ...types.filter(isEnumType5).map((type) => enumBlock(type, naming)),
+    ...types.filter(isInputObjectType4).map((type) => inputBlock(type, writer, naming, cyclic)),
+    ...types.flatMap((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);
+        const members = field.args.map((arg) => [
+          arg.name,
+          {
+            ...writer.value(arg.type, constraintsOn(writer.directive, arg.astNode), `${type.name}.${field.name}(${arg.name}:)`, defaultLiteral(arg)),
+            description: arg.description
+          }
+        ]);
+        return declare(name, naming, `z.object({
+${objectMembers(members)}
+})`, "output");
+      });
+    })
+  ];
+}
+function enumBlock(type, naming) {
+  const values = type.getValues().map((value) => JSON.stringify(value.name));
+  return declare(naming.type(type.name), naming, `z.enum([${values.join(", ")}])`, "output", type.description);
+}
+function inputBlock(type, writer, naming, cyclic) {
+  const code = inputCode(type, writer);
+  return cyclic.has(type.name) ? declareCyclic(type, code, writer, naming, cyclic) : declare(naming.type(type.name), naming, code, "output", type.description);
+}
+function inputCode(type, writer) {
+  const fields = Object.values(type.getFields());
+  const constraints = (field) => constraintsOn(writer.directive, field.astNode);
+  const where = (field) => `${type.name}.${field.name}`;
+  if (type.isOneOf) {
+    const members = fields.map((field) => {
+      const member = {
+        ...writer.required(field.type, constraints(field), where(field)),
+        description: field.description
+      };
+      return `	z.strictObject({
+${indent(objectMembers([[field.name, member]]))}
+	})`;
+    });
+    return `z.union([
+${members.join(`,
+`)},
+])`;
+  }
+  const members = fields.map((field) => [
+    field.name,
+    {
+      ...writer.value(field.type, constraints(field), where(field), defaultLiteral(field)),
+      description: field.description
+    }
+  ]);
+  return `z.strictObject({
+${objectMembers(members)}
+})`;
+}
+function indent(code) {
+  return code.split(`
+`).map((line) => `	${line}`).join(`
+`);
+}
+
+// src/variables-output.ts
+import {
+  constraintsOn as constraintsOn2
+} from "@nxgt/graphql-validation/codegen";
+import {
+  getNamedType as getNamedType5,
+  isInputObjectType as isInputObjectType5,
+  isListType as isListType6,
+  isNonNullType as isNonNullType6,
+  Kind as Kind4,
+  TypeInfo,
+  typeFromAST,
+  visit,
+  visitWithTypeInfo
+} 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 === 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 [];
+    const used = usages(schema, writer.directive, operation, fragments);
+    const members = (operation.variableDefinitions ?? []).map((definition) => {
+      const variable = definition.variable.name.value;
+      const type = typeFromAST(schema, definition.type);
+      if (!type) {
+        throw new Error(`@nxgt/graphql-codegen-zod: ${operationName}'s $${variable} has a type the schema does not define.`);
+      }
+      const where = `${operationName}($${variable}:)`;
+      const constraints = merged(used.get(variable) ?? [], where);
+      return [
+        variable,
+        writer.value(type, constraints, where, definition.defaultValue)
+      ];
+    });
+    return [
+      declare(naming.variables(operationName, operation.operation), naming, `z.object({
+${objectMembers(members)}
+})`, "input")
+    ];
+  });
+}
+function usages(schema, directive, operation, fragments) {
+  const walk = {
+    found: new Map,
+    variables: new Set((operation.variableDefinitions ?? []).map((d) => d.variable.name.value)),
+    directive
+  };
+  const seen = new Set;
+  const visitNode = (node) => {
+    const typeInfo = new TypeInfo(schema);
+    visit(node, visitWithTypeInfo(typeInfo, {
+      Argument(argument) {
+        const definition = typeInfo.getArgument();
+        const field = typeInfo.getFieldDef();
+        if (!definition || !field || typeInfo.getDirective() !== null)
+          return;
+        const where = `${typeInfo.getParentType()?.name}.${field.name}(${definition.name}:)`;
+        walkValue(walk, argument.value, definition.type, constraintsOn2(directive, definition.astNode), where);
+      },
+      FragmentSpread(spread) {
+        const fragment = fragments.get(spread.name.value);
+        if (fragment && !seen.has(fragment.name.value)) {
+          seen.add(fragment.name.value);
+          visitNode(fragment);
+        }
+      }
+    }));
+  };
+  visitNode(operation);
+  return walk.found;
+}
+function walkValue(walk, value, type, constraints, where) {
+  if (value.kind === Kind4.VARIABLE) {
+    if (!walk.variables.has(value.name.value))
+      return;
+    const list = walk.found.get(value.name.value) ?? [];
+    list.push({ where, constraints });
+    walk.found.set(value.name.value, list);
+    return;
+  }
+  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 = getNamedType5(type);
+  if (value.kind === Kind4.OBJECT && isInputObjectType5(named)) {
+    for (const field of value.fields) {
+      const definition = named.getFields()[field.name.value];
+      if (definition) {
+        walkValue(walk, field.value, definition.type, constraintsOn2(walk.directive, definition.astNode), `${named.name}.${definition.name}`);
+      }
+    }
+  }
+}
+function merged(usages, where) {
+  const all = [];
+  for (const usage of usages) {
+    for (const constraint of usage.constraints) {
+      const same = all.some((known) => known.rule === constraint.rule && known.value === constraint.value);
+      if (!same)
+        all.push({ ...constraint, at: usage.where });
+    }
+  }
+  const bases = all.filter(({ rule }) => rule.base);
+  const [first, second] = bases;
+  if (first && second) {
+    throw new Error(`@nxgt/graphql-codegen-zod: ${where} is passed to ${first.at} (${first.rule.argument}: ${JSON.stringify(first.value)}) and to ${second.at} (${second.rule.argument}: ${JSON.stringify(second.value)}), whose schemas cannot both apply. Use one variable for each.`);
+  }
+  return [...bases, ...all.filter(({ rule }) => !rule.base)].map(({ rule, value }) => ({ rule, value }));
+}
+
+// src/writer.ts
+import {
+  inputCode as inputCode2
+} from "@nxgt/graphql-validation/codegen";
+import {
+  GraphQLNonNull,
+  getNamedType as getNamedType6,
+  isEnumType as isEnumType6,
+  isInputObjectType as isInputObjectType6,
+  isNonNullType as isNonNullType7,
+  isScalarType as isScalarType4,
+  isSpecifiedScalarType as isSpecifiedScalarType2
+} from "graphql";
+class Writer {
+  directive;
+  #naming;
+  #scalars;
+  constructor(directive, naming, scalars) {
+    this.directive = directive;
+    this.#naming = naming;
+    this.#scalars = scalars;
+  }
+  scalarCode(type) {
+    return this.#scalars.code(type);
+  }
+  schemaName(type) {
+    return this.#naming.schema(this.#naming.type(type.name));
+  }
+  value(type, constraints, where, defaultValue) {
+    let lazy = false;
+    const named = (named) => {
+      if (isInputObjectType6(named)) {
+        lazy = true;
+        return this.schemaName(named);
+      }
+      if (isEnumType6(named))
+        return this.schemaName(named);
+      return this.#scalars.code(named);
+    };
+    if (!defaultValue)
+      return {
+        code: inputCode2(type, constraints, where, named, {
+          list: singleOrList
+        }),
+        lazy
+      };
+    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 {
+      code: `${required}.prefault(${value})${nullable ? ".nullable()" : ""}`,
+      lazy
+    };
+  }
+  required(type, constraints, where) {
+    return this.value(isNonNullType7(type) ? type : new GraphQLNonNull(type), constraints, where);
+  }
+}
+var singleOrList = ({
+  type,
+  code,
+  single
+}) => {
+  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})])`;
+};
+
+// src/index.ts
+async function plugin(schema, documents, config = {}, info) {
+  const directive = checkConstraints(schema);
+  if (directive)
+    assertSdl(schema);
+  const naming = new Naming(config);
+  const write = async (imports) => {
+    const scalars = await ScalarSources.load(config, imports, info?.outputFile);
+    const writer = new Writer(directive, naming, scalars);
+    return [
+      ...schemaBlocks(schema, 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 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 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);
+  return `${imports.lines().join(`
+`)}
+
+${blocks.join(`
+
+`)}
+`;
+}
+function assertSdl(schema) {
+  for (const type of Object.values(schema.getTypeMap())) {
+    if (type.name.startsWith("__"))
+      continue;
+    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.`);
+    }
+  }
+}
+export {
+  plugin
+};
+
+//# debugId=7FB3A417D01910B464756E2164756E21
+//# sourceMappingURL=index.js.map