@drzl/cli 4.23.0 → 4.24.1

package/dist/dist-UVP6B4XJ.js

@@ -1,646 +0,0 @@
-// ../generator-graphql/dist/index.js
-import { fileWriter } from "@drzl/validation-core";
-import {
-  formatCode,
-  importSpecifier,
-  insertColumns,
-  isIntegerColumn,
-  selectColumns,
-  updateColumns
-} from "@drzl/validation-core";
-var APP_MODULE = "index";
-var SCALARS_MODULE = "scalars";
-var GRAPHQL_NAME = /^[_A-Za-z][_0-9A-Za-z]*$/;
-var RESERVED_ENUM_VALUES = /* @__PURE__ */ new Set(["true", "false", "null"]);
-var INT32_MIN = -2147483648n;
-var INT32_MAX = 2147483647n;
-var cap = (s) => s.charAt(0).toUpperCase() + s.slice(1);
-var isIdent = (s) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(s);
-var q = (v) => `'${v.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
-function gqlIdent(s) {
-  const cleaned = s.replace(/[^_0-9A-Za-z]+/g, "_");
-  return /^[0-9]/.test(cleaned) ? `_${cleaned}` : cleaned;
-}
-function tpl(s) {
-  return s.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
-}
-function keyColumns(table) {
-  const names = table.primaryKey?.columns ?? [];
-  if (!names.length) return null;
-  const cols = names.map((n) => table.columns.find((c) => c.name === n));
-  if (cols.some((c) => !c)) return null;
-  return cols;
-}
-function fitsInt32(c) {
-  if (c.min === void 0 || c.max === void 0) return false;
-  try {
-    return BigInt(c.min) >= INT32_MIN && BigInt(c.max) <= INT32_MAX;
-  } catch {
-    return false;
-  }
-}
-function planEnum(typeName, values) {
-  const members = values.map((value) => {
-    const verbatimOk = GRAPHQL_NAME.test(value) && !RESERVED_ENUM_VALUES.has(value) && !value.startsWith("__");
-    if (verbatimOk) return { name: value, value, renamed: false };
-    let name = gqlIdent(value.toUpperCase());
-    name = name.replace(/^_+/, "_");
-    if (!GRAPHQL_NAME.test(name) || RESERVED_ENUM_VALUES.has(name) || name.startsWith("__")) {
-      return { name: "", value, renamed: true };
-    }
-    return { name, value, renamed: true };
-  });
-  if (members.some((m) => !m.name)) return null;
-  const seen = /* @__PURE__ */ new Set();
-  for (const m of members) {
-    if (seen.has(m.name)) return null;
-    seen.add(m.name);
-  }
-  return { typeName, members };
-}
-function mapped(sdl, rowTs, inputTs = rowTs, scalars = []) {
-  return { sdl, rowTs, inputTs, scalars };
-}
-function planColumn(table, c) {
-  const field = GRAPHQL_NAME.test(c.name) ? c.name : gqlIdent(c.name);
-  const base = (() => {
-    if (c.enumValues && c.enumValues.length) {
-      const typeName = `${cap(gqlIdent(table.tsName))}${cap(gqlIdent(c.name))}Enum`;
-      const plan = planEnum(typeName, c.enumValues);
-      if (!plan) {
-        return {
-          ...mapped("String", "string"),
-          note: `Column "${c.name}": the enum values ${c.enumValues.join(", ")} cannot all be spelled as distinct GraphQL enum members, so the column is exposed as String carrying the database values verbatim.`
-        };
-      }
-      const union = c.enumValues.map(q).join(" | ");
-      return { ...mapped(plan.typeName, union), enumPlan: plan };
-    }
-    switch (c.shape?.kind) {
-      case "tuple":
-        return mapped("[Float!]", "number[]");
-      case "numberObject":
-        return mapped("JSON", "unknown", "unknown", ["JSON"]);
-      case "buffer":
-        return {
-          ...mapped("JSON", "unknown", "unknown", ["JSON"]),
-          note: `Column "${c.name}" is binary; GraphQL has no binary type, so it rides the JSON scalar and your resolver picks an encoding.`
-        };
-      case "json":
-        return mapped("JSON", "unknown", "unknown", ["JSON"]);
-      case "bitstring":
-      case "byteString":
-        return mapped("String", "string");
-      default:
-        break;
-    }
-    if (c.dbType === "VECTOR") return mapped("[Float!]", "number[]");
-    switch (c.tsType) {
-      case "number":
-        return mapped(isIntegerColumn(c) && fitsInt32(c) ? "Int" : "Float", "number");
-      case "string":
-        return mapped(c.format === "uuid" ? "ID" : "String", "string");
-      case "boolean":
-        return mapped("Boolean", "boolean");
-      case "Date":
-        return mapped("DateTime", "Date", "Date", ["DateTime"]);
-      case "bigint":
-        return mapped("BigInt", "string | bigint", "string", ["BigInt"]);
-      default:
-        return {
-          ...mapped("JSON", "unknown", "unknown", ["JSON"]),
-          note: `No GraphQL type for column "${c.name}": DRZL could not derive one from the schema, so it is exposed through the JSON scalar and accepts any value there.`
-        };
-    }
-  })();
-  let { sdl, rowTs, inputTs } = base;
-  const dims = c.arrayDimensions ?? 0;
-  for (let i = 0; i < dims; i++) {
-    sdl = `[${sdl}]`;
-    rowTs = `(${rowTs} | null)[]`;
-    inputTs = `(${inputTs} | null)[]`;
-  }
-  return {
-    column: c,
-    field,
-    renamed: field !== c.name,
-    sdl,
-    rowTs,
-    inputTs,
-    scalars: base.scalars,
-    enumPlan: base.enumPlan,
-    note: base.note
-  };
-}
-function planTable(table) {
-  const typeName = cap(gqlIdent(table.tsName));
-  const fieldBase = gqlIdent(table.tsName);
-  const select = selectColumns(table).map((c) => planColumn(table, c));
-  const writable = !table.readOnly;
-  const insert = writable ? insertColumns(table).map((c) => planColumn(table, c)) : [];
-  const update = writable ? updateColumns(table).map((c) => planColumn(table, c)) : [];
-  const keyCols = keyColumns(table);
-  const key = keyCols ? keyCols.map((c) => planColumn(table, c)) : null;
-  const scalars = /* @__PURE__ */ new Set();
-  const enums = [];
-  const notes = [];
-  for (const p of select) {
-    for (const s of p.scalars) scalars.add(s);
-    if (p.enumPlan) enums.push(p.enumPlan);
-    if (p.note) notes.push(p.note);
-  }
-  const createInput = `Create${typeName}Input`;
-  const updateInput = `Update${typeName}Input`;
-  const hasCreate = writable && insert.length > 0;
-  const hasUpdate = writable && key !== null && update.length > 0;
-  const keyArgsSdl = key ? key.map((p) => `${p.field}: ${p.sdl}!`).join(", ") : "";
-  const keyArgsTs = key ? key.map((p) => `${p.field}: ${p.inputTs}`).join("; ") : "";
-  const ops = [];
-  ops.push({
-    parent: "Query",
-    name: fieldBase,
-    argsSdl: "",
-    resultSdl: `[${typeName}!]!`,
-    argsTs: "Record<string, never>",
-    resultTs: `${typeName}[]`
-  });
-  if (key) {
-    ops.push({
-      parent: "Query",
-      name: `${fieldBase}ById`,
-      argsSdl: keyArgsSdl,
-      resultSdl: typeName,
-      argsTs: `{ ${keyArgsTs} }`,
-      resultTs: `${typeName} | null`
-    });
-  }
-  if (hasCreate) {
-    ops.push({
-      parent: "Mutation",
-      name: `create${typeName}`,
-      argsSdl: `input: ${createInput}!`,
-      resultSdl: `${typeName}!`,
-      argsTs: `{ input: ${createInput} }`,
-      resultTs: typeName
-    });
-  }
-  if (hasUpdate) {
-    ops.push({
-      parent: "Mutation",
-      name: `update${typeName}`,
-      argsSdl: `${keyArgsSdl}, input: ${updateInput}!`,
-      resultSdl: `${typeName}!`,
-      argsTs: `{ ${keyArgsTs}; input: ${updateInput} }`,
-      resultTs: typeName
-    });
-  }
-  if (writable && key) {
-    ops.push({
-      parent: "Mutation",
-      name: `delete${typeName}`,
-      argsSdl: keyArgsSdl,
-      resultSdl: "Boolean!",
-      argsTs: `{ ${keyArgsTs} }`,
-      resultTs: "boolean"
-    });
-  }
-  const renamedSelect = select.filter((p) => p.renamed);
-  for (const p of renamedSelect) {
-    notes.push(
-      `Column "${p.column.name}" is not a valid GraphQL field name, so it is exposed as "${p.field}": output is mapped back by the emitted field resolver, and on inputs the value arrives under "${p.field}" for your resolver to write back.`
-    );
-  }
-  return {
-    table,
-    typeName,
-    createInput,
-    updateInput,
-    select,
-    insert,
-    update,
-    key,
-    writable,
-    hasCreate,
-    hasUpdate,
-    ops,
-    scalars,
-    enums,
-    notes,
-    renamedSelect
-  };
-}
-function renderEnumSdl(plan) {
-  const lines = [`enum ${plan.typeName} {`];
-  for (const m of plan.members) {
-    if (m.renamed) lines.push(`  ${JSON.stringify(`Database value: ${m.value}`)}`);
-    lines.push(`  ${m.name}`);
-  }
-  lines.push("}");
-  return lines.join("\n");
-}
-function renderTypeSdl(plan) {
-  const parts = [];
-  for (const e of plan.enums) parts.push(renderEnumSdl(e));
-  parts.push(
-    [
-      `type ${plan.typeName} {`,
-      ...plan.select.map((p) => `  ${p.field}: ${p.sdl}${p.column.nullable ? "" : "!"}`),
-      "}"
-    ].join("\n")
-  );
-  if (plan.hasCreate) {
-    parts.push(
-      [
-        `input ${plan.createInput} {`,
-        ...plan.insert.map((p) => {
-          const required = !p.column.nullable && !p.column.hasDefault;
-          return `  ${p.field}: ${p.sdl}${required ? "!" : ""}`;
-        }),
-        "}"
-      ].join("\n")
-    );
-  }
-  if (plan.hasUpdate) {
-    parts.push(
-      [
-        `input ${plan.updateInput} {`,
-        ...plan.update.map((p) => `  ${p.field}: ${p.sdl}`),
-        "}"
-      ].join("\n")
-    );
-  }
-  return parts.join("\n\n");
-}
-function rowField(p) {
-  const key = isIdent(p.column.name) ? p.column.name : q(p.column.name);
-  return `  ${key}: ${p.rowTs}${p.column.nullable ? " | null" : ""};`;
-}
-function inputField(p, mode) {
-  const required = mode === "insert" && !p.column.nullable && !p.column.hasDefault;
-  return required ? `  ${p.field}: ${p.inputTs};` : `  ${p.field}?: ${p.inputTs} | null;`;
-}
-var stubBody = (parent, name) => `throw new Error('Not implemented: ${parent}.${name}. Replace this stub with your data layer.');`;
-function renderResolvers(plan) {
-  const lines = ["{"];
-  const byParent = (parent) => plan.ops.filter((o) => o.parent === parent);
-  const renderOps = (parent) => {
-    lines.push(`  ${parent}: {`);
-    for (const op of byParent(parent)) {
-      lines.push(
-        `    ${op.name}: (_parent: unknown, _args: ${op.argsTs}): ${op.resultTs} => {`,
-        `      ${stubBody(parent, op.name)}`,
-        `    },`
-      );
-    }
-    lines.push("  },");
-  };
-  renderOps("Query");
-  if (byParent("Mutation").length) renderOps("Mutation");
-  for (const e of plan.enums) {
-    const mapped2 = e.members.filter((m) => m.renamed);
-    if (!mapped2.length) continue;
-    lines.push(
-      `  ${e.typeName}: { ${mapped2.map((m) => `${m.name}: ${q(m.value)}`).join(", ")} },`
-    );
-  }
-  if (plan.renamedSelect.length) {
-    lines.push(`  ${plan.typeName}: {`);
-    for (const p of plan.renamedSelect) {
-      const type = `${p.rowTs}${p.column.nullable ? " | null" : ""}`;
-      lines.push(`    ${p.field}: (parent: ${plan.typeName}): ${type} => parent[${q(p.column.name)}],`);
-    }
-    lines.push("  },");
-  }
-  lines.push("}");
-  return lines.join("\n");
-}
-function renderTable(plan) {
-  const t = plan.table;
-  const declared = [];
-  declared.push(
-    `/** One ${t.name} row, as your resolvers return it: database values, database spellings. */`,
-    `export interface ${plan.typeName} {`,
-    ...plan.select.map(rowField),
-    "}"
-  );
-  if (plan.hasCreate) {
-    declared.push(
-      "",
-      `/** The create${plan.typeName} input, as GraphQL hands it to your resolver. */`,
-      `export interface ${plan.createInput} {`,
-      ...plan.insert.map((p) => inputField(p, "insert")),
-      "}"
-    );
-  }
-  if (plan.hasUpdate) {
-    declared.push(
-      "",
-      `/** The update${plan.typeName} patch: every field optional, primary key excluded. */`,
-      `export interface ${plan.updateInput} {`,
-      ...plan.update.map((p) => inputField(p, "update")),
-      "}"
-    );
-  }
-  const tsName = gqlIdent(t.tsName);
-  const notes = plan.notes.length ? plan.notes.map((n) => `// ${n.replace(/\n/g, " ")}`).join("\n") + "\n" : "";
-  return `// Generated by @drzl/generator-graphql
-// GraphQL SDL and resolver stubs for table: ${t.name}
-${notes}${declared.join("\n")}
-
-/** The SDL for this table's types. The Query and Mutation fields live in the barrel. */
-export const ${tsName}TypeDefs = \`${tpl(renderTypeSdl(plan))}\`;
-
-/** Stubs that throw until replaced, plus the enum value maps and field resolvers the schema needs. */
-export const ${tsName}Resolvers = ${renderResolvers(plan)};
-`;
-}
-function renderScalarsModule() {
-  return `// Generated by @drzl/generator-graphql
-// Dependency-free scalar configs for the resolvers map. Each hook is named twice because
-// graphql 17 renamed serialize/parseValue/parseLiteral to coerceOutputValue/coerceInputValue/
-// coerceInputLiteral, and the schema builder assigns whichever names the running graphql reads.
-
-/** The literal AST shape the literal hooks read, structurally, so nothing is imported. */
-export interface LiteralNode {
-  kind: string;
-  value?: unknown;
-  values?: LiteralNode[];
-  fields?: { name: { value: string }; value: LiteralNode }[];
-  name?: { value: string };
-}
-
-// Strict ISO 8601 datetime with seconds and an offset: new Date('1') is the year 2001.
-const ISO_DATETIME = /^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?(Z|[+-]\\d{2}:\\d{2})$/;
-
-const toIso = (value: unknown): string => {
-  if (value instanceof Date && !Number.isNaN(value.getTime())) return value.toISOString();
-  throw new Error('DateTime.serialize: expected a Date');
-};
-const fromIso = (value: unknown): Date => {
-  if (typeof value !== 'string' || !ISO_DATETIME.test(value)) {
-    throw new Error('DateTime: expected a strict ISO 8601 datetime string');
-  }
-  const parsed = new Date(value);
-  if (Number.isNaN(parsed.getTime())) throw new Error('DateTime: unreadable datetime string');
-  return parsed;
-};
-const fromIsoLiteral = (ast: LiteralNode): Date => {
-  if (ast.kind !== 'StringValue') throw new Error('DateTime: expected a string literal');
-  return fromIso(ast.value);
-};
-
-/** ISO 8601 datetime string in, real Date to the resolver, toISOString() out. */
-export const DateTimeScalar = {
-  name: 'DateTime',
-  description: 'A strict ISO 8601 datetime string, e.g. 2026-01-02T03:04:05.000Z.',
-  serialize: toIso,
-  parseValue: fromIso,
-  parseLiteral: fromIsoLiteral,
-  coerceOutputValue: toIso,
-  coerceInputValue: fromIso,
-  coerceInputLiteral: fromIsoLiteral,
-};
-
-const DIGITS = /^-?\\d+$/;
-
-const toDigits = (value: unknown): string => {
-  if (typeof value === 'bigint') return value.toString();
-  if (typeof value === 'string' && DIGITS.test(value)) return value;
-  throw new Error('BigInt.serialize: expected a bigint or a decimal digit string');
-};
-// Variables take the digit string only: a JSON number was already rounded by JSON.parse.
-const fromDigits = (value: unknown): string => {
-  if (typeof value !== 'string' || !DIGITS.test(value)) {
-    throw new Error('BigInt: expected a string of decimal digits');
-  }
-  return value;
-};
-// An inline integer literal is lossless: the AST carries its raw digits as a string.
-const fromDigitsLiteral = (ast: LiteralNode): string => {
-  if (ast.kind === 'IntValue') return String(ast.value);
-  if (ast.kind === 'StringValue' && typeof ast.value === 'string' && DIGITS.test(ast.value)) {
-    return ast.value;
-  }
-  throw new Error('BigInt: expected an integer literal or a string of decimal digits');
-};
-
-/** A 64-bit-safe integer crossing the wire as its decimal digits. */
-export const BigIntScalar = {
-  name: 'BigInt',
-  description: 'An arbitrary-precision integer as a string of decimal digits.',
-  serialize: toDigits,
-  parseValue: fromDigits,
-  parseLiteral: fromDigitsLiteral,
-  coerceOutputValue: toDigits,
-  coerceInputValue: fromDigits,
-  coerceInputLiteral: fromDigitsLiteral,
-};
-
-const identity = (value: unknown): unknown => value;
-const fromJSONLiteral = (ast: LiteralNode, variables?: Record<string, unknown> | null): unknown => {
-  switch (ast.kind) {
-    case 'StringValue':
-    case 'BooleanValue':
-    case 'EnumValue':
-      return ast.value;
-    case 'IntValue':
-    case 'FloatValue':
-      return Number(ast.value);
-    case 'NullValue':
-      return null;
-    case 'ListValue':
-      return (ast.values ?? []).map((v) => fromJSONLiteral(v, variables));
-    case 'ObjectValue': {
-      const out: Record<string, unknown> = {};
-      for (const f of ast.fields ?? []) out[f.name.value] = fromJSONLiteral(f.value, variables);
-      return out;
-    }
-    case 'Variable':
-      return variables ? variables[ast.name?.value ?? ''] : undefined;
-    default:
-      throw new Error('JSON: unsupported literal kind ' + ast.kind);
-  }
-};
-
-/** Any JSON value, untouched on both value paths, rebuilt from the AST for inline literals. */
-export const JSONScalar = {
-  name: 'JSON',
-  description: 'Any JSON value, passed through as-is.',
-  serialize: identity,
-  parseValue: identity,
-  parseLiteral: fromJSONLiteral,
-  coerceOutputValue: identity,
-  coerceInputValue: identity,
-  coerceInputLiteral: fromJSONLiteral,
-};
-`;
-}
-var SCALAR_EXPORTS = {
-  DateTime: "DateTimeScalar",
-  BigInt: "BigIntScalar",
-  JSON: "JSONScalar"
-};
-function renderBarrel(plans, modules, usedScalars, scalarsSpec) {
-  if (!plans.length) {
-    return `// Generated by @drzl/generator-graphql
-// No tables detected in analysis. Add tables to your schema and regenerate.
-// A GraphQL schema needs a Query type with at least one field, so no typeDefs are composed.
-export * from '${scalarsSpec}';
-
-export const typeDefs = '';
-
-export const resolvers = {};
-`;
-  }
-  const imports = [];
-  if (usedScalars.length) {
-    const names = usedScalars.map((s) => SCALAR_EXPORTS[s]).sort();
-    imports.push(`import { ${names.join(", ")} } from '${scalarsSpec}';`);
-  }
-  for (const plan of plans) {
-    const tsName = gqlIdent(plan.table.tsName);
-    imports.push(
-      `import { ${tsName}Resolvers, ${tsName}TypeDefs } from '${modules.get(plan)}';`
-    );
-  }
-  const reExports = [
-    `export * from '${scalarsSpec}';`,
-    ...plans.map((p) => `export * from '${modules.get(p)}';`)
-  ];
-  const queryLines = plans.flatMap(
-    (p) => p.ops.filter((o) => o.parent === "Query").map((o) => `  ${o.name}${o.argsSdl ? `(${o.argsSdl})` : ""}: ${o.resultSdl}`)
-  );
-  const mutationLines = plans.flatMap(
-    (p) => p.ops.filter((o) => o.parent === "Mutation").map((o) => `  ${o.name}(${o.argsSdl}): ${o.resultSdl}`)
-  );
-  const typeDefParts = [
-    ...usedScalars.map((s) => `'scalar ${s}'`),
-    ...plans.map((p) => `${gqlIdent(p.table.tsName)}TypeDefs`),
-    `\`${tpl(["type Query {", ...queryLines, "}"].join("\n"))}\``
-  ];
-  if (mutationLines.length) {
-    typeDefParts.push(`\`${tpl(["type Mutation {", ...mutationLines, "}"].join("\n"))}\``);
-  }
-  const resolverLines = ["export const resolvers = {"];
-  for (const s of usedScalars) resolverLines.push(`  ${s}: ${SCALAR_EXPORTS[s]},`);
-  for (const p of plans) {
-    const tsName = gqlIdent(p.table.tsName);
-    for (const e of p.enums) {
-      if (e.members.some((m) => m.renamed)) {
-        resolverLines.push(`  ${e.typeName}: ${tsName}Resolvers.${e.typeName},`);
-      }
-    }
-    if (p.renamedSelect.length) {
-      resolverLines.push(`  ${p.typeName}: ${tsName}Resolvers.${p.typeName},`);
-    }
-  }
-  resolverLines.push("  Query: {");
-  for (const p of plans) resolverLines.push(`    ...${gqlIdent(p.table.tsName)}Resolvers.Query,`);
-  resolverLines.push("  },");
-  const mutating = plans.filter((p) => p.ops.some((o) => o.parent === "Mutation"));
-  if (mutating.length) {
-    resolverLines.push("  Mutation: {");
-    for (const p of mutating) {
-      resolverLines.push(`    ...${gqlIdent(p.table.tsName)}Resolvers.Mutation,`);
-    }
-    resolverLines.push("  },");
-  }
-  resolverLines.push("};");
-  return `// Generated by @drzl/generator-graphql
-// The whole schema in one pair: hand typeDefs and resolvers to makeExecutableSchema,
-// createSchema (graphql-yoga) or new ApolloServer(...). Plain buildSchema(typeDefs) accepts
-// the SDL too, but takes no resolvers, so scalar and enum behaviour will not attach there.
-${imports.join("\n")}
-
-${reExports.join("\n")}
-
-/** The whole schema's SDL. */
-export const typeDefs = [
-${typeDefParts.map((p) => `  ${p},`).join("\n")}
-].join('\\n\\n');
-
-/** Everything merged. Override per field: { ...resolvers, Query: { ...resolvers.Query, users: yours } } */
-${resolverLines.join("\n")}
-`;
-}
-function buildHeader(h) {
-  if (h && h.enabled === false) return "";
-  const text = h?.text?.trim();
-  const lines = text ? text.split(/\r?\n/).map((l) => `// ${l}`) : [
-    "// Generated by DRZL (@drzl/*)",
-    "// Generated output is granted to you under your project's license.",
-    "// You may use, copy, modify, and distribute without attribution."
-  ];
-  return lines.join("\n") + "\n\n";
-}
-function toCase(s, c) {
-  if (!c) return s;
-  const parts = s.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_-]/g, " ").split(/\s+/);
-  if (c === "camel") {
-    return parts.map(
-      (p, i) => i === 0 ? p.toLowerCase() : p.charAt(0).toUpperCase() + p.slice(1).toLowerCase()
-    ).join("");
-  }
-  if (c === "kebab") return parts.map((p) => p.toLowerCase()).join("-");
-  if (c === "snake") return parts.map((p) => p.toLowerCase()).join("_");
-  return s;
-}
-var GraphQLGenerator = class {
-  constructor(analysis) {
-    this.analysis = analysis;
-  }
-  async generate(opts) {
-    const fs = fileWriter(opts.fileSink);
-    const path = await import("path");
-    const out = path.resolve(process.cwd(), opts.outputDir);
-    await fs.mkdir(out, { recursive: true });
-    const files = [];
-    const write = async (filePath, content) => {
-      const formatted = await formatCode(
-        buildHeader(opts.outputHeader) + content,
-        filePath,
-        opts.format
-      );
-      await fs.writeFile(filePath, formatted, "utf8");
-      files.push(filePath);
-    };
-    const barrelPath = path.join(out, `${APP_MODULE}.ts`);
-    const scalarsPath = path.join(out, `${SCALARS_MODULE}.ts`);
-    const plans = this.analysis.tables.map(planTable);
-    const modules = /* @__PURE__ */ new Map();
-    const total = plans.length;
-    let index = 0;
-    for (const plan of plans) {
-      const base = `${plan.table.tsName}${opts.naming?.routerSuffix ?? ""}`;
-      const filePath = path.join(out, `${toCase(base, opts.naming?.procedureCase)}.ts`);
-      if (filePath === barrelPath || filePath === scalarsPath) {
-        const which = filePath === barrelPath ? "the barrel" : "the scalars module";
-        throw new Error(
-          `@drzl/generator-graphql: the module for table "${plan.table.name}" would be written to ${filePath}, which is ${which} this generator also writes. Set naming.routerSuffix to move it out of the way.`
-        );
-      }
-      await write(filePath, renderTable(plan));
-      modules.set(
-        plan,
-        importSpecifier("./" + path.relative(out, filePath).replace(/\\/g, "/"), opts.importExtension)
-      );
-      index++;
-      opts.onProgress?.({ index, total, table: plan.table.name, filePath });
-    }
-    const usedScalars = ["DateTime", "BigInt", "JSON"].filter(
-      (s) => plans.some((p) => p.scalars.has(s))
-    );
-    const scalarsSpec = importSpecifier(`./${SCALARS_MODULE}.ts`, opts.importExtension);
-    await write(scalarsPath, renderScalarsModule());
-    await write(barrelPath, renderBarrel(plans, modules, usedScalars, scalarsSpec));
-    return { files };
-  }
-};
-var index_default = GraphQLGenerator;
-export {
-  APP_MODULE,
-  GraphQLGenerator,
-  SCALARS_MODULE,
-  index_default as default
-};
-//# sourceMappingURL=dist-UVP6B4XJ.js.map