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

package/dist/index.js

@@ -0,0 +1,717 @@
+// src/index.ts
+import { checkConstraints } from "@nxgt/graphql-validation/codegen";
+import {
+  isInputObjectType as isInputObjectType7,
+  isInterfaceType as isInterfaceType2,
+  isObjectType as isObjectType2
+} 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) {
+    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`));
+  }
+  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/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 isEnumType2,
+  isInputObjectType as isInputObjectType4,
+  isInterfaceType,
+  isObjectType
+} 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,
+  getNullableType,
+  isInputObjectType as isInputObjectType2,
+  isListType,
+  isNonNullType,
+  isScalarType,
+  isSpecifiedScalarType,
+  Kind,
+  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 (isListType(nullable)) {
+    const items = literal.kind === Kind.LIST ? literal.values : [literal];
+    for (const item of items)
+      assertExact(item, nullable.ofType, where);
+    return;
+  }
+  if (isInputObjectType2(nullable)) {
+    if (literal.kind !== Kind.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 === GraphQLID || isScalarType(nullable) && !isSpecifiedScalarType(nullable);
+  if (keeps && literal.kind === Kind.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 = isNonNullType(type) ? type.ofType : type;
+  if (value === null || value === undefined)
+    return value;
+  if (isListType(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 (getNamedType2(nullable) === GraphQLID && 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,
+  isInputObjectType as isInputObjectType3,
+  isListType as isListType2,
+  isNonNullType as isNonNullType2
+} from "graphql";
+var builtIns = {
+  [GraphQLString.name]: "string",
+  [GraphQLID2.name]: "string",
+  [GraphQLInt.name]: "number",
+  [GraphQLFloat.name]: "number",
+  [GraphQLBoolean.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 = !isNonNullType2(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 (isNonNullType2(type))
+      return this.#required(type.ofType, side);
+    if (!isListType2(type))
+      return this.#named(type, side);
+    const item = isNonNullType2(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;
+  }
+  #named(type, side) {
+    const builtIn = builtIns[type.name];
+    if (builtIn)
+      return builtIn;
+    if (isEnumType(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(isEnumType2).map((type) => enumBlock(type, naming)),
+    ...types.filter(isInputObjectType4).map((type) => inputBlock(type, writer, naming, cyclic)),
+    ...types.flatMap((type) => {
+      if (!isObjectType(type) && !isInterfaceType(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 getNamedType4,
+  isInputObjectType as isInputObjectType5,
+  isListType as isListType3,
+  isNonNullType as isNonNullType3,
+  Kind as Kind2,
+  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 === Kind2.FRAGMENT_DEFINITION).map((node) => [node.name.value, node]));
+  return definitions.filter((node) => node.kind === Kind2.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 === Kind2.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 = isNonNullType3(type) ? type.ofType : type;
+  if (value.kind === Kind2.LIST && isListType3(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)) {
+    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 getNamedType5,
+  isEnumType as isEnumType3,
+  isInputObjectType as isInputObjectType6,
+  isNonNullType as isNonNullType4,
+  isScalarType as isScalarType2,
+  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 (isEnumType3(named))
+        return this.schemaName(named);
+      return this.#scalars.code(named);
+    };
+    if (!defaultValue)
+      return {
+        code: inputCode2(type, constraints, where, named, {
+          list: singleOrList
+        }),
+        lazy
+      };
+    const nullable = !isNonNullType4(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(isNonNullType4(type) ? type : new GraphQLNonNull(type), constraints, where);
+  }
+}
+var singleOrList = ({
+  type,
+  code,
+  single
+}) => {
+  const named = getNamedType5(type);
+  const transforms = isInputObjectType6(named) || isScalarType2(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),
+      ...variablesBlocks(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 an input type in a cycle and its Input type, give the same name. Rename one of the GraphQL types, or set typesSuffix.`);
+  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()) : isObjectType2(type) || isInterfaceType2(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=AA4EFD5F1FAF8A9864756E2164756E21
+//# sourceMappingURL=index.js.map