@drzl/cli 4.19.0 → 4.23.0

package/dist/chunk-54E2IO7N.js

@@ -0,0 +1,1030 @@
+// src/config.ts
+import {
+  AFFIX_PREFIX_PATTERN,
+  AFFIX_PROBE_TABLE,
+  AFFIX_SUFFIX_PATTERN,
+  DEFAULT_IMPORT_EXTENSION,
+  IMPORT_EXTENSIONS,
+  NAME_MODES,
+  resolveAffix,
+  schemaName,
+  validateAffix
+} from "@drzl/validation-core";
+import * as fs from "fs";
+import { createRequire } from "module";
+import * as path from "path";
+import { z } from "zod";
+
+// src/config-errors.ts
+function hasOwn(object, key) {
+  return Object.prototype.hasOwnProperty.call(object, key);
+}
+var CONFIG_INVALID_CODE = "DRZL_CFG_002";
+var ConfigValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.code = CONFIG_INVALID_CODE;
+    this.name = "ConfigValidationError";
+  }
+};
+var MAX_LISTED_PROBLEMS = 8;
+var MAX_VALUE_CHARS = 60;
+function renderConfigPath(segments) {
+  if (!segments.length) return "(root)";
+  let out = "";
+  for (const segment of segments) {
+    if (typeof segment === "number") {
+      out += `[${segment}]`;
+      continue;
+    }
+    const key = String(segment);
+    if (/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key)) out += out ? `.${key}` : key;
+    else out += `[${JSON.stringify(key)}]`;
+  }
+  return out;
+}
+function describeValue(value) {
+  if (value === void 0) return "undefined";
+  if (value === null) return "null";
+  switch (typeof value) {
+    case "boolean":
+      return String(value);
+    case "number":
+      return String(value);
+    case "bigint":
+      return `${value}n`;
+    case "function":
+      return "[function]";
+    case "symbol":
+      return String(value);
+    case "string":
+      return value.length <= MAX_VALUE_CHARS ? JSON.stringify(value) : `${JSON.stringify(value.slice(0, MAX_VALUE_CHARS))} ... (${value.length} characters)`;
+  }
+  let json;
+  try {
+    json = JSON.stringify(value);
+  } catch {
+    return null;
+  }
+  if (typeof json !== "string") return null;
+  return json.length <= MAX_VALUE_CHARS ? json : null;
+}
+function valueAt(raw, segments) {
+  let current = raw;
+  for (const segment of segments) {
+    if (current === null || typeof current !== "object") return { found: false, value: void 0 };
+    if (!hasOwn(current, String(segment))) return { found: false, value: void 0 };
+    current = current[segment];
+  }
+  return { found: true, value: current };
+}
+function editDistance(a, b) {
+  if (a === b) return 0;
+  if (!a.length) return b.length;
+  if (!b.length) return a.length;
+  let previous = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 1; i <= a.length; i++) {
+    const current = new Array(b.length + 1);
+    current[0] = i;
+    for (let j = 1; j <= b.length; j++) {
+      const substitution = previous[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1);
+      current[j] = Math.min(current[j - 1] + 1, previous[j] + 1, substitution);
+    }
+    previous = current;
+  }
+  return previous[b.length];
+}
+function nearestKey(key, known) {
+  const budget = key.length >= 5 ? 2 : 1;
+  let best;
+  let bestDistance = Number.POSITIVE_INFINITY;
+  for (const candidate of known) {
+    if (candidate === key) return void 0;
+    const distance = editDistance(key, candidate);
+    if (distance <= budget && distance < bestDistance) {
+      best = candidate;
+      bestDistance = distance;
+    }
+  }
+  return best;
+}
+function objectNodeFor(node) {
+  if (!node || typeof node !== "object") return void 0;
+  const record = node;
+  const anyOf = record.anyOf;
+  if (Array.isArray(anyOf)) {
+    const branches = anyOf.filter(
+      (branch) => branch && typeof branch === "object" && (branch.properties !== void 0 || typeof branch.additionalProperties === "object")
+    );
+    return branches.length === 1 ? branches[0] : void 0;
+  }
+  if (record.properties !== void 0 || record.additionalProperties !== void 0) return record;
+  return void 0;
+}
+function unknownConfigKeys(raw, schema) {
+  const found = [];
+  walkForUnknownKeys(raw, schema, [], found);
+  return found;
+}
+function walkForUnknownKeys(value, node, segments, found) {
+  if (value === null || typeof value !== "object") return;
+  if (Array.isArray(value)) {
+    const items = node?.items;
+    if (!items) return;
+    value.forEach((entry, index) => walkForUnknownKeys(entry, items, [...segments, index], found));
+    return;
+  }
+  const object = objectNodeFor(node);
+  if (!object) return;
+  const properties = object.properties;
+  const additional = object.additionalProperties;
+  if (!properties) {
+    if (additional && typeof additional === "object") {
+      for (const [key, entry] of Object.entries(value)) {
+        walkForUnknownKeys(entry, additional, [...segments, key], found);
+      }
+    }
+    return;
+  }
+  const known = Object.keys(properties);
+  for (const [key, entry] of Object.entries(value)) {
+    if (hasOwn(properties, key)) {
+      walkForUnknownKeys(entry, properties[key], [...segments, key], found);
+      continue;
+    }
+    if (additional === false) continue;
+    found.push({ path: [...segments], key, suggestion: nearestKey(key, known) });
+  }
+}
+function unknownKeyWarnings(raw, schema) {
+  return unknownConfigKeys(raw, schema).map((unknown) => {
+    const where = unknown.path.length ? `in ${renderConfigPath(unknown.path)}` : "at the top level";
+    const suggestion = unknown.suggestion ? ` Did you mean "${unknown.suggestion}"?` : "";
+    return `drzl config: unknown key "${unknown.key}" ${where}; it is ignored.${suggestion}`;
+  });
+}
+function nodeAt(schema, segments) {
+  let node = schema;
+  for (const segment of segments) {
+    if (typeof segment === "number") {
+      node = node?.items;
+      continue;
+    }
+    const object = objectNodeFor(node);
+    if (!object) return void 0;
+    const properties = object.properties;
+    if (properties && hasOwn(properties, String(segment))) {
+      node = properties[String(segment)];
+      continue;
+    }
+    const additional = object.additionalProperties;
+    if (additional && typeof additional === "object") {
+      node = additional;
+      continue;
+    }
+    return void 0;
+  }
+  return objectNodeFor(node);
+}
+function knownKeysAt(schema, segments) {
+  const node = nodeAt(schema, segments);
+  const properties = node?.properties;
+  return properties ? Object.keys(properties) : [];
+}
+function renderIssue(issue, raw, schema) {
+  const segments = issue.path ?? [];
+  const where = renderConfigPath(segments);
+  if (issue.code === "unrecognized_keys" && issue.keys?.length) {
+    const known = knownKeysAt(schema, segments);
+    return issue.keys.map((key) => {
+      const suggestion = nearestKey(key, known);
+      return `${where}: unrecognized key "${key}".${suggestion ? ` Did you mean "${suggestion}"?` : ""}`;
+    });
+  }
+  const what = String(issue.message ?? "is not valid").replace(/^Invalid input:\s*/, "");
+  const { found, value } = valueAt(raw, segments);
+  const shown = found ? describeValue(value) : null;
+  return [`${where}: ${what}${shown === null ? "" : ` (found ${shown})`}`];
+}
+function formatConfigProblems(file, issues, raw, schema) {
+  const lines = issues.flatMap((issue) => renderIssue(issue, raw, schema));
+  const shown = lines.slice(0, MAX_LISTED_PROBLEMS);
+  const rest = lines.length - shown.length;
+  const header = `${file} is not valid (${CONFIG_INVALID_CODE}). ${lines.length} problem${lines.length === 1 ? "" : "s"}:`;
+  const body = shown.map((line) => `  - ${line}`);
+  if (rest > 0) body.push(`  ... and ${rest} more`);
+  return [header, ...body].join("\n");
+}
+
+// src/patterns.ts
+function patternToRegExp(pattern) {
+  return new RegExp(
+    "^" + pattern.split("*").map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join(".*") + "$"
+  );
+}
+function matchesAny(patterns, name) {
+  return patterns.some((p) => patternToRegExp(p).test(name));
+}
+var DEFAULT_SCHEMA_ALIAS = "public";
+function tableAliases(table) {
+  return [table.name, `${table.schema ?? DEFAULT_SCHEMA_ALIAS}.${table.name}`];
+}
+function matchesTable(patterns, table) {
+  return tableAliases(table).some((alias) => matchesAny(patterns, alias));
+}
+function displayTableName(table) {
+  return table.schema ? `${table.schema}.${table.name}` : table.name;
+}
+function addressableName(table) {
+  return `${table.schema ?? DEFAULT_SCHEMA_ALIAS}.${table.name}`;
+}
+function hasNamedSchemas(tables) {
+  return tables.some((t) => t.schema);
+}
+function ambiguousPatternWarnings(patterns, tables, option) {
+  const out = [];
+  for (const pattern of patterns) {
+    if (pattern.includes(".")) continue;
+    const matched = tables.filter((t) => matchesTable([pattern], t));
+    const schemas = new Set(matched.map((t) => t.schema ?? DEFAULT_SCHEMA_ALIAS));
+    if (schemas.size < 2) continue;
+    out.push(
+      `drzl config: ${option} pattern ${JSON.stringify(pattern)} matches tables in more than one schema, and every one of them is affected: ${matched.map(addressableName).sort().join(", ")}. Write the schema to mean one of them, for example ${JSON.stringify(addressableName(matched[0]))}.`
+    );
+  }
+  return out;
+}
+
+// src/config.ts
+var NamingSchema = z.object({
+  routerSuffix: z.string().default("Router"),
+  procedureCase: z.enum(["camel", "kebab", "snake"]).default("camel")
+}).partial();
+var affixValueSchema = (pattern) => z.union(
+  [
+    z.string().meta({ pattern }),
+    z.object({
+      insert: z.string().meta({ pattern }).optional(),
+      update: z.string().meta({ pattern }).optional(),
+      select: z.string().meta({ pattern }).optional()
+    }).strict()
+  ],
+  {
+    error: 'Expected a string to use for every mode, or an object with any of the keys "insert", "update" and "select". Those keys are lowercase, matching the mode names drzl uses everywhere else.'
+  }
+);
+var AffixPartSchema = z.object({
+  prefix: affixValueSchema(AFFIX_PREFIX_PATTERN).optional(),
+  suffix: affixValueSchema(AFFIX_SUFFIX_PATTERN).optional()
+}).strict();
+var AffixSchema = z.object({
+  /**
+   * `preserve` (default) keeps today's output: the Drizzle export name goes into the
+   * identifier verbatim, so `export const users` yields `InsertusersSchema`. `pascal`
+   * upper-camels it first, yielding `InsertUsersSchema`.
+   */
+  tableCase: z.enum(["preserve", "pascal"]).optional(),
+  schema: AffixPartSchema.optional(),
+  type: AffixPartSchema.optional()
+}).strict();
+var ImportExtensionSchema = z.enum(IMPORT_EXTENSIONS);
+var GeneratorKindSchema = z.enum([
+  "orpc",
+  "trpc",
+  "hono",
+  "express",
+  "fastify",
+  "nestjs",
+  "graphql",
+  "service",
+  "zod",
+  "valibot",
+  "arktype",
+  "typebox",
+  "effect",
+  "json-schema"
+]);
+var GENERATOR_KINDS = GeneratorKindSchema.options;
+var GeneratorSchema = z.object({
+  kind: GeneratorKindSchema,
+  /**
+   * Which of Hono's two official validator middlewares the emitted routes carry, and therefore
+   * which package they import. `hono` only.
+   *
+   * `standard` is `sValidator` from `@hono/standard-validator`, which takes any Standard Schema
+   * and so works with every library `validation.library` can name. `zod` is `zValidator` from
+   * `@hono/zod-validator`, which is zod-specific.
+   */
+  validator: z.enum(["standard", "zod"]).optional(),
+  /**
+   * Overrides the top-level `importExtension` for this generator alone, for a project whose
+   * generated directories are compiled by different tsconfigs.
+   */
+  importExtension: ImportExtensionSchema.optional(),
+  template: z.string().optional(),
+  includeRelations: z.boolean().optional(),
+  /**
+   * Write an enum used by two or more columns once under `$defs` in the `json-schema` per-table
+   * modules, and `$ref` it at each use.
+   *
+   * Off by default, and the reason is a consumer pattern rather than a doubt about the keyword. A
+   * per-table schema is used whole and one property at a time, and a `$ref` cannot survive being
+   * pulled out with its property: `properties[col]` compiled on its own is a dangling reference
+   * that ajv refuses outright. The OpenAPI document shares regardless, because a document is only
+   * ever read whole.
+   */
+  sharedEnums: z.boolean().optional(),
+  /**
+   * Type `json` and `jsonb` columns from the schema rather than leaving them wide.
+   *
+   * `.$type<T>()` is a compile-time cast, so no runtime-derived validator can see it and
+   * `drizzle-orm/zod` types every json column as its generic `Json`. A generator can reference
+   * `typeof <table>.$inferSelect['<column>']` instead, which is the declared type resolved by
+   * TypeScript itself, so generics, unions and imported interfaces all work.
+   *
+   * Off by default because it makes the generated file import your schema module, as a
+   * type-only import that disappears at build time.
+   */
+  // What a date column accepts. Documented on the zod generator and, until now, accepted by the
+  // config parser and then dropped on the floor: the generators default it to 'input' themselves,
+  // so setting it here changed nothing.
+  coerceDates: z.enum(["input", "all", "none"]).optional(),
+  typedJson: z.boolean().optional(),
+  // The wider form: every column's static type comes from Drizzle, not just the untyped ones.
+  typedColumns: z.boolean().optional(),
+  // Reproduce literal column defaults in the insert schema, so parsing fills them in.
+  applyDefaults: z.boolean().optional(),
+  /**
+   * Emit `findDuplicate<Table>` beside the schemas: the rows in a batch that collide with an
+   * earlier row on a unique constraint.
+   *
+   * Uniqueness is the one constraint a per-row validator structurally cannot see, since it is a
+   * fact about the table rather than the row. This checks the half that needs no database.
+   */
+  duplicateFinder: z.boolean().optional(),
+  /**
+   * zod and valibot. Also emit `constraints.ts`: every CHECK, unique constraint, primary and
+   * foreign key on each table as plain data, plus `constraintForIssue`, which maps a validation
+   * issue back to the constraint that caused it.
+   *
+   * For building forms. A schema states what a value must look like and never says which
+   * constraint said so, so a failed parse hands a form a message and no way to attribute it; and
+   * uniqueness and foreign keys, the two constraints no per-row schema can check, are absent from
+   * the emitted schemas in every form.
+   *
+   * Not `meta` written to a second file. `meta` describes a *field* and travels with the schema
+   * into `z.toJSONSchema`; this describes the table's *constraints*, carries their names, states
+   * each operand as data rather than inside a sentence, and is read without holding a schema.
+   *
+   * `true` is the shorthand for `{ enabled: true }`. `{ errorMap: false }` emits the data alone,
+   * without the matcher.
+   */
+  constraints: z.union([
+    z.boolean(),
+    z.object({ enabled: z.boolean().optional(), errorMap: z.boolean().optional() }).strict()
+  ]).optional(),
+  /**
+   * zod only. Attach the facts the analyzer knows and a zod schema cannot state, as `.meta()` on
+   * every field and every table schema: the declared SQL type, the primary key, the unique
+   * constraints, whether the database generates or defaults the value, and the CHECK constraints,
+   * including the ones DRZL declined to enforce.
+   *
+   * `z.toJSONSchema` copies these through, so they are also how an OpenAPI document built from the
+   * emitted schemas gets the declared width back: DRZL enforces one as a `.refine()`, and
+   * `toJSONSchema` drops every refinement in silence.
+   *
+   * `true` is the shorthand for `{ enabled: true }`. `{ description: true }` additionally writes a
+   * `description`, which is what an OpenAPI viewer renders to a human.
+   */
+  meta: z.union([
+    z.boolean(),
+    z.object({ enabled: z.boolean().optional(), description: z.boolean().optional() }).strict()
+  ]).optional(),
+  /**
+   * TypeBox only. Give every emitted schema a `~standard` key, so it can be handed to a tRPC or
+   * oRPC route.
+   *
+   * TypeBox is the one validator DRZL emits that carries none of its own: measured on 0.34.52, a
+   * bare `Type.Object()` has no `~standard` and the package exports nothing matching
+   * `/standard/i`. zod, valibot and arktype all put one on every schema they build, so the option
+   * does nothing for them and is not passed through.
+   *
+   * The property is non-enumerable, so the schema stays a TypeBox schema in every respect that was
+   * already observable, including the JSON Schema `JSON.stringify` produces.
+   */
+  standardSchema: z.boolean().optional(),
+  /**
+   * Emit `NestedInsert<Table>` and `NestedSelect<Table>` beside the flat schemas: the table plus
+   * one key per relation, so `{ ...user, posts: [...] }` can be validated whole.
+   *
+   * Nothing in the Drizzle validator ecosystem describes that payload, and `db.insert` drops the
+   * relation key silently rather than refusing it, so the children are never written and nothing
+   * says so.
+   */
+  nestedSchemas: z.boolean().optional(),
+  /**
+   * How many levels of children a nested schema describes. Defaults to 1, capped at 3.
+   *
+   * Nesting is expanded inline rather than by reference, so this multiplies the emitted size, and
+   * it is also what terminates a cycle: `users -> posts -> users` stops here.
+   */
+  nestedDepth: z.number().int().optional(),
+  /**
+   * Give every primary key, and every foreign key pointing at one, a nominal type, so a
+   * `users.id` cannot be passed where a `posts.id` is wanted.
+   *
+   * Type level only, in all five validators. Measured on zod 4.4.3, `.brand()` returns the same
+   * schema object it was called on and the parsed value of `1` is `1`, so nothing about what a
+   * schema accepts changes and no bytes are added to the bundle. TypeBox has no brand of its own
+   * and gets a `TUnsafe` cast, which leaves the schema object identical.
+   *
+   * Off by default: it changes the inferred type of every consumer of the select schemas, which
+   * is the point, but it is a change to existing call sites rather than an addition.
+   *
+   * `true` is the shorthand for `{ enabled: true }`. `{ foreignKeys: false }` brands only the
+   * keys themselves, and `{ aliases: false }` stops the `export type UsersId = ...` lines.
+   */
+  branded: z.union([
+    z.boolean(),
+    z.object({
+      enabled: z.boolean().optional(),
+      foreignKeys: z.boolean().optional(),
+      aliases: z.boolean().optional()
+    }).strict()
+  ]).optional(),
+  naming: NamingSchema.optional(),
+  outputHeader: z.object({
+    enabled: z.boolean().default(true).optional(),
+    text: z.string().optional()
+  }).optional(),
+  format: z.object({
+    enabled: z.boolean().default(true).optional(),
+    engine: z.enum(["auto", "prettier", "biome"]).default("auto").optional(),
+    configPath: z.string().optional()
+  }).optional(),
+  /**
+   * Which spelling of JSON Schema the `json-schema` generator emits.
+   *
+   * OpenAPI 3.0 is not an older superset of the 2020-12 draft, it is a different dialect: a
+   * nullable type is `nullable: true` rather than a type array, and an exclusive bound is a
+   * boolean flag beside the bound rather than its own keyword. An unknown keyword is not an error
+   * in JSON Schema, it is ignored, so emitting the wrong dialect produces a document that
+   * validates and then accepts the values the constraints exist to reject.
+   */
+  target: z.enum(["draft-2020-12", "openapi-3.1", "openapi-3.0"]).optional(),
+  /** Also emit `components.ts` for the `json-schema` generator, ready for an OpenAPI document. */
+  components: z.boolean().optional(),
+  /**
+   * Also emit the whole OpenAPI document for the `json-schema` generator: paths, verbs, request and
+   * response bodies per table, with `components.schemas` embedded so the file stands alone.
+   *
+   * `true` is the short form. The object form carries the three things a Drizzle schema genuinely
+   * cannot say: what the API is called, where it is served, and which status code that particular
+   * server answers a request that fails its schema with.
+   */
+  document: z.union([
+    z.boolean(),
+    z.object({
+      enabled: z.boolean().optional(),
+      /** `ts` (default) writes a module, `json` the file OpenAPI tooling reads directly. */
+      format: z.enum(["ts", "json", "both"]).optional(),
+      info: z.object({
+        title: z.string().optional(),
+        version: z.string().optional(),
+        description: z.string().optional()
+      }).strict().optional(),
+      /**
+       * Omitted by default, which the specification reads as a single server at `/`: the
+       * document describes whatever is serving it. A placeholder host would be a fabrication
+       * that tooling then follows.
+       */
+      servers: z.array(z.object({ url: z.string(), description: z.string().optional() }).strict()).optional(),
+      /** 400 by default. 422 is the other defensible reading; exactly one is emitted. */
+      validationStatus: z.union([z.literal(400), z.literal(422)]).optional()
+    }).strict()
+  ]).optional(),
+  // service generator specific options
+  path: z.string().optional(),
+  dataAccess: z.enum(["stub", "drizzle"]).default("stub").optional(),
+  dbImportPath: z.string().optional(),
+  schemaImportPath: z.string().optional(),
+  // zod/valibot/arktype generator specific options
+  schemaSuffix: z.string().optional(),
+  fileSuffix: z.string().optional(),
+  /**
+   * Prefixes, suffixes and table casing for generated identifiers (zod/valibot/arktype).
+   * Omitting it reproduces the output of every previous release exactly.
+   */
+  affix: AffixSchema.optional(),
+  /**
+   * How the router generators reach a database handle: through the request context, rather than
+   * through a module-level import in the service layer.
+   *
+   * Documented on the oRPC generator since it was added and, until now, absent from this schema
+   * entirely. `GeneratorSchema` is not strict, so zod stripped the key without a word and the
+   * option did nothing at all when set from a config file. It was only ever reachable by calling
+   * the generator's API directly.
+   */
+  databaseInjection: z.object({
+    enabled: z.boolean().optional(),
+    /** The type annotation for the injected handle, e.g. `DrizzleD1Database`. */
+    databaseType: z.string().optional(),
+    databaseTypeImport: z.object({ name: z.string(), from: z.string() }).optional()
+  }).optional(),
+  // router validation sharing (orpc, trpc)
+  validation: z.object({
+    useShared: z.boolean().default(false).optional(),
+    library: z.enum(["zod", "valibot", "arktype"]).default("zod").optional(),
+    importPath: z.string().optional(),
+    schemaSuffix: z.string().optional(),
+    /**
+     * How the validation generator named its exports. Usually left unset: the CLI copies
+     * it from the sibling generator whose `kind` matches `library`.
+     */
+    affix: AffixSchema.optional()
+  }).optional(),
+  // template options
+  templateOptions: z.record(z.string(), z.any()).optional()
+});
+var ColumnRulesSchema = z.object({
+  omit: z.array(z.string()).optional(),
+  pick: z.array(z.string()).optional()
+}).strict();
+var AnalyzerSchema = z.object({
+  includeRelations: z.boolean().default(true),
+  validateConstraints: z.boolean().default(true),
+  includeHeuristicRelations: z.boolean().default(false)
+});
+var ConfigSchema = z.object({
+  /**
+   * Path to the Drizzle schema module. Optional since drizzle-kit interop: a project that
+   * already names its schema in `drizzle.config.ts` should not have to say it twice, so an
+   * omitted `schema` falls back to reading the drizzle-kit config (see `drizzleKit`). The
+   * "neither file names a schema" error is raised at resolution time, where it can name both
+   * files, rather than here, where "Required" could name only this one.
+   */
+  schema: z.string().optional(),
+  /**
+   * Read the schema path from drizzle-kit's own config instead of `schema`.
+   *
+   * `true` reads `drizzle.config.ts`, then `.js`, then `.json`, the same candidates in the
+   * same order drizzle-kit's CLI uses (measured on drizzle-kit 0.31.10). A string reads that
+   * file, wherever it is, like kit's own `--config` flag. `false` disables the fallback, so
+   * an omitted `schema` is an error even beside a drizzle.config. Unset behaves like `true`
+   * whenever `schema` is omitted, and does nothing when `schema` is set: `schema` always
+   * wins, with a warning when both are stated.
+   *
+   * Only kit's `schema` (string or array, entries may be globs) and `dialect` (cross-checked
+   * against what the analyzer detects) are read. Everything else in that file describes
+   * migrations and database credentials, which DRZL has no use for.
+   */
+  drizzleKit: z.union([z.boolean(), z.string()], {
+    error: "Expected true (read drizzle.config.ts/.js/.json, the same candidates drizzle-kit uses), false (never read one), or a path to the drizzle-kit config file."
+  }).optional(),
+  outDir: z.string().default("src/api"),
+  /**
+   * Which tables to generate for, matched against the database table name.
+   *
+   * There was no way to say this, and every generator loops over every table it finds, so
+   * DRZL emitted unauthenticated CRUD over whatever shared the schema file. That is noise for
+   * a migrations table and a genuine leak for an auth one: Better Auth puts `user`, `session`,
+   * `account` and `verification` alongside your own tables, and `account` holds
+   * `accessToken`, `refreshToken`, `idToken` and `password`.
+   *
+   * Deliberately name-based and explicit rather than detecting any particular library. Auth
+   * table names are all renameable, so a built-in list would miss renamed tables and, worse,
+   * silently skip an ordinary table that happened to be called `user`, which is usually the
+   * application's main entity.
+   *
+   * `exclude` wins over `include`. Patterns support `*`, matching within a name.
+   */
+  include: z.array(z.string()).optional(),
+  exclude: z.array(z.string()).optional(),
+  /**
+   * Which columns of those tables to generate for, keyed by table.
+   *
+   * `include`/`exclude` is all or nothing per table, and the column that should not be in a
+   * generated schema is usually sitting in a table you do want: `passwordHash` on `users`, an
+   * internal note beside the public fields, a `tenantId` the server sets from the session and a
+   * request body must not carry. Editing the emitted file is not an answer, because the next
+   * `drzl generate` overwrites it.
+   *
+   * ```ts
+   * columns: {
+   *   users: { omit: ['passwordHash'] },
+   *   'app_*': { omit: ['deleted_at'] },
+   * }
+   * ```
+   *
+   * The key is a table pattern in the same language `include`/`exclude` uses: the database table
+   * name, anchored, with `*` as the only metacharacter. Column patterns are the same language
+   * again. Every matching entry applies, in the order written; within one entry `pick` narrows
+   * first and `omit` then removes, so `omit` wins, exactly as `exclude` wins over `include`.
+   *
+   * Applies to every mode and every generator at once, because it narrows the analysis rather
+   * than any one generator's output. A column cannot be kept in `select` and dropped from
+   * `insert`: see the docs for why that form was not taken on.
+   *
+   * A pattern that matches nothing is an error rather than a no-op, because a typo in `omit`
+   * that silently does nothing leaves the column exactly where it was while reading like a fix.
+   * Dropping a primary key column is an error too; dropping a NOT NULL column with no default is
+   * a warning.
+   */
+  columns: z.record(z.string(), ColumnRulesSchema).optional(),
+  /**
+   * How every relative specifier drzl invents spells its extension, for every generator.
+   * A generator may override it. Defaults to `js`, which is the only form that resolves
+   * under every `moduleResolution` without a compiler flag.
+   */
+  importExtension: ImportExtensionSchema.default(DEFAULT_IMPORT_EXTENSION),
+  analyzer: AnalyzerSchema.default({
+    includeRelations: true,
+    validateConstraints: true,
+    includeHeuristicRelations: false
+  }),
+  generators: z.array(GeneratorSchema).min(1).default([{ kind: "orpc" }])
+}).superRefine((cfg, ctx) => {
+  cfg.generators.forEach((g, i) => {
+    const report = (base, affix, schemaSuffix) => {
+      for (const issue of validateAffix(affix, schemaSuffix)) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["generators", i, ...base, ...issue.path],
+          message: issue.message
+        });
+      }
+    };
+    report(["affix"], g.affix, g.schemaSuffix);
+    report(
+      ["validation", "affix"],
+      g.validation?.affix,
+      g.validation?.schemaSuffix
+    );
+  });
+});
+function defineConfig(cfg) {
+  return cfg;
+}
+var CONFIG_FILE_NAMES = [
+  "drzl.config.ts",
+  "drzl.config.mjs",
+  "drzl.config.js",
+  "drzl.config.cjs",
+  "drzl.config.json"
+];
+var CONFIG_SCHEMA_ID = "https://use-drzl.github.io/drzl/drzl.config.schema.json";
+function buildConfigJsonSchema() {
+  const generated = z.toJSONSchema(ConfigSchema, {
+    io: "input",
+    target: "draft-7"
+  });
+  const properties = {
+    // Declared so an editor suggests it and does not report the pointer a reader was told to
+    // add as an unknown key. `ConfigSchema` is not strict, so the CLI strips it and never sees it.
+    $schema: {
+      type: "string",
+      description: "Path or URL of this schema, for editor completion. Ignored by drzl."
+    },
+    ...generated.properties
+  };
+  const { $schema, properties: _dropped, ...rest } = generated;
+  return {
+    $schema,
+    $id: CONFIG_SCHEMA_ID,
+    title: "DRZL configuration",
+    description: "Configuration for the drzl CLI. Also describes drzl.config.ts, which gets the same shape from the defineConfig export of @drzl/cli/config.",
+    ...rest,
+    properties
+  };
+}
+var ROUTER_KINDS = /* @__PURE__ */ new Set(["orpc", "trpc", "hono", "express"]);
+var INJECTION_KINDS = /* @__PURE__ */ new Set(["orpc", "trpc"]);
+function trpcOutDir(g, cfg) {
+  return g.path ?? cfg.outDir;
+}
+function honoOutDir(g, cfg) {
+  return g.path ?? cfg.outDir;
+}
+function expressOutDir(g, cfg) {
+  return g.path ?? cfg.outDir;
+}
+function fastifyOutDir(g, cfg) {
+  return g.path ?? cfg.outDir;
+}
+function nestjsOutDir(g, cfg) {
+  return g.path ?? cfg.outDir;
+}
+function graphqlOutDir(g, cfg) {
+  return g.path ?? cfg.outDir;
+}
+function sharedSchemaNames(opts) {
+  const resolved = resolveAffix(opts);
+  return NAME_MODES.map((mode) => schemaName(mode, AFFIX_PROBE_TABLE, resolved));
+}
+function resolveConfig(cfg) {
+  const warnings = [];
+  const generators = cfg.generators.map((g) => ({
+    ...g,
+    importExtension: g.importExtension ?? cfg.importExtension
+  }));
+  for (const g of generators) {
+    if (g.kind === "fastify") {
+      if (g.databaseInjection?.enabled) {
+        warnings.push(
+          `drzl config: the "fastify" generator sets databaseInjection.enabled, which it does not support. Its handlers are stubs and never call a service, so nothing reads the injected handle. Reach your database from inside the handler bodies you fill in, or use the "trpc" or "orpc" generator, which do delegate to @drzl/generator-service.`
+        );
+      }
+      if (g.validation) {
+        warnings.push(
+          `drzl config: the "fastify" generator sets "validation", which it does not read. Its route schemas are JSON Schema produced by the same builder as the "json-schema" generator and inlined into the routes, so there is no library to choose and no shared schema module to import. Remove the block.`
+        );
+      }
+      continue;
+    }
+    if (g.kind === "nestjs") {
+      if (g.databaseInjection?.enabled) {
+        warnings.push(
+          `drzl config: the "nestjs" generator sets databaseInjection.enabled, which it does not support. It emits DTO classes with no handlers at all, so nothing reads the injected handle. Reach your database from the controllers you write around these DTOs, or use the "trpc" or "orpc" generator, which do delegate to @drzl/generator-service.`
+        );
+      }
+      if (g.includeRelations) {
+        warnings.push(
+          `drzl config: the "nestjs" generator sets includeRelations, which it does not read. Relation lookups are routes, and this generator emits DTO classes for your own controllers rather than routes. Remove the flag.`
+        );
+      }
+      if (g.validation?.useShared || g.validation?.importPath) {
+        warnings.push(
+          `drzl config: the "nestjs" generator sets validation.useShared or validation.importPath, which it does not read. Its DTO modules are self-contained: the class fields and the schema are generated from the same columns, and wrapping a schema another generator wrote would let the two drift. Only validation.library is read on this kind.`
+        );
+      }
+      if (g.validation?.schemaSuffix || g.validation?.affix) {
+        warnings.push(
+          `drzl config: the "nestjs" generator sets validation.schemaSuffix or validation.affix, which it does not read. Those options spell the names of shared schema modules, and this generator imports none. Only validation.library is read on this kind.`
+        );
+      }
+      continue;
+    }
+    if (g.kind === "graphql") {
+      if (g.databaseInjection?.enabled) {
+        warnings.push(
+          `drzl config: the "graphql" generator sets databaseInjection.enabled, which it does not support. It emits SDL and resolver stubs with no handlers at all, so nothing reads the injected handle. Reach your database from the resolvers you write in place of the stubs, or use the "trpc" or "orpc" generator, which do delegate to @drzl/generator-service.`
+        );
+      }
+      if (g.includeRelations) {
+        warnings.push(
+          `drzl config: the "graphql" generator sets includeRelations, which it does not read. Relation lookups are routes on the router generators, and relation fields on a GraphQL type are resolvers you write against your own data layer. Remove the flag.`
+        );
+      }
+      if (g.validation) {
+        warnings.push(
+          `drzl config: the "graphql" generator sets "validation", which it does not read. Its schema is GraphQL SDL, GraphQL's own type language, so there is no library to choose and no shared schema module to import. Remove the block.`
+        );
+      }
+      continue;
+    }
+    if (!ROUTER_KINDS.has(g.kind)) continue;
+    if (g.databaseInjection?.enabled && !INJECTION_KINDS.has(g.kind)) {
+      warnings.push(
+        `drzl config: the "${g.kind}" generator sets databaseInjection.enabled, which it does not support. Its handlers are stubs and never call a service, so nothing reads the injected handle. Reach your database from inside the handler bodies you fill in, or use the "trpc" or "orpc" generator, which do delegate to @drzl/generator-service.`
+      );
+    } else if (g.databaseInjection?.enabled) {
+      for (const s of generators.filter((x) => x.kind === "service")) {
+        if (!s.databaseInjection) {
+          s.databaseInjection = g.databaseInjection;
+        } else if (!s.databaseInjection.enabled) {
+          warnings.push(
+            `drzl config: the "${g.kind}" generator sets databaseInjection.enabled while the "service" generator sets it to false. The router will call Service.method(ctx.db, ...) against services that take no database parameter, so the generated project will not compile. Set both, or neither.`
+          );
+        }
+        if ((s.dataAccess ?? "stub") === "stub") {
+          warnings.push(
+            `drzl config: the "${g.kind}" generator sets databaseInjection.enabled, so its handlers call Service.method(ctx.db, ...). The "service" generator emits stub bodies, which take no database parameter whatever this option says, so those calls will not compile. Set dataAccess: 'drizzle' on the "service" generator, or drop databaseInjection.`
+          );
+        }
+      }
+    }
+    const v = g.validation;
+    if (!v?.useShared) continue;
+    const library = v.library ?? "zod";
+    const siblings = generators.filter((s) => s.kind === library);
+    if (siblings.length !== 1) continue;
+    const sibling = siblings[0];
+    const theirs = sharedSchemaNames({
+      affix: sibling.affix,
+      schemaSuffix: sibling.schemaSuffix
+    });
+    if (!v.affix) {
+      if (sibling.affix) {
+        g.validation = {
+          ...v,
+          affix: resolveAffix({
+            affix: sibling.affix,
+            schemaSuffix: sibling.schemaSuffix
+          })
+        };
+        continue;
+      }
+      const mine2 = sharedSchemaNames({ schemaSuffix: v.schemaSuffix });
+      if (mine2.join(",") !== theirs.join(",")) {
+        warnings.push(
+          `drzl config: the "${g.kind}" generator's validation.schemaSuffix (${JSON.stringify(v.schemaSuffix ?? "Schema")}) does not match the "${library}" generator's schemaSuffix (${JSON.stringify(sibling.schemaSuffix ?? "Schema")}). The router will import ${mine2.join(", ")} but the "${library}" generator exports ${theirs.join(", ")}, so the generated router will not compile. Set both to the same value, or move to "affix", which is inherited automatically.`
+        );
+      }
+      continue;
+    }
+    const mine = sharedSchemaNames({
+      affix: v.affix,
+      schemaSuffix: v.schemaSuffix
+    });
+    if (mine.join(",") !== theirs.join(",")) {
+      throw new Error(
+        `drzl config: the "${g.kind}" generator imports shared ${library} schemas, but its validation.affix disagrees with the "${library}" generator's own naming. The router would import ${mine.join(", ")} while the "${library}" generator exports ${theirs.join(", ")}. Make them match, or drop validation.affix and let it be inherited from the "${library}" generator.`
+      );
+    }
+  }
+  return { config: { ...cfg, generators }, warnings };
+}
+var configShape = null;
+function configShapeForReading() {
+  return configShape ??= buildConfigJsonSchema();
+}
+function displayConfigPath(file, cwd = process.cwd()) {
+  const relative2 = path.relative(cwd, file);
+  return relative2 && !relative2.startsWith("..") ? relative2 : file;
+}
+function finalize(raw, file, onWarn) {
+  const parsed = ConfigSchema.safeParse(raw);
+  if (!parsed.success) {
+    throw new ConfigValidationError(
+      formatConfigProblems(
+        displayConfigPath(file),
+        parsed.error.issues,
+        raw,
+        configShapeForReading()
+      )
+    );
+  }
+  for (const w of unknownKeyWarnings(raw, configShapeForReading())) onWarn(w);
+  const { config, warnings } = resolveConfig(parsed.data);
+  for (const w of warnings) onWarn(w);
+  return config;
+}
+async function importFreshConfigModule(p) {
+  const fsp = await import("fs/promises");
+  const ext = path.extname(p).toLowerCase();
+  if (ext === ".json") {
+    return JSON.parse(await fsp.readFile(p, "utf8"));
+  }
+  const { createJiti } = await import("jiti");
+  const stat = await fsp.stat(p);
+  const base = typeof __filename !== "undefined" ? __filename : path.join(process.cwd(), "index.js");
+  const jiti = createJiti(base, {
+    moduleCache: false,
+    // re-evaluate each time
+    fsCache: true,
+    // keep transform cache
+    cacheVersion: String(stat.mtimeMs),
+    // bump on edit
+    interopDefault: true,
+    tryNative: false
+    // <-- prevent native import of .ts
+    // debug: true,
+  });
+  const mod = await jiti.import(p);
+  return mod?.default ?? mod;
+}
+async function loadConfig(customPath, onWarn = (warning) => console.warn(warning)) {
+  const fsp = await import("fs/promises");
+  const candidates = customPath ? [customPath] : [...CONFIG_FILE_NAMES];
+  for (const c of candidates) {
+    const p = path.resolve(process.cwd(), c);
+    try {
+      await fsp.access(p);
+    } catch {
+      continue;
+    }
+    return finalize(await importFreshConfigModule(p), p, onWarn);
+  }
+  return null;
+}
+function configFromKinds(kinds, schema, onWarn = () => {
+}) {
+  const parsed = ConfigSchema.parse({
+    ...schema ? { schema } : {},
+    generators: kinds.map((kind) => ({ kind }))
+  });
+  const { config, warnings } = resolveConfig(parsed);
+  for (const w of warnings) onWarn(w);
+  return config;
+}
+function computeGeneratorOutputDirs(cfg, cwd = process.cwd()) {
+  const abs = (p) => path.resolve(cwd, p);
+  const dirs = /* @__PURE__ */ new Set();
+  dirs.add(abs(cfg.outDir));
+  for (const g of cfg.generators) {
+    if (g.kind === "trpc") dirs.add(abs(trpcOutDir(g, cfg)));
+    if (g.kind === "hono") dirs.add(abs(honoOutDir(g, cfg)));
+    if (g.kind === "express") dirs.add(abs(expressOutDir(g, cfg)));
+    if (g.kind === "fastify") dirs.add(abs(fastifyOutDir(g, cfg)));
+    if (g.kind === "nestjs") dirs.add(abs(nestjsOutDir(g, cfg)));
+    if (g.kind === "graphql") dirs.add(abs(graphqlOutDir(g, cfg)));
+    if (g.kind === "service") dirs.add(abs(g.path ?? "src/services"));
+    if (g.kind === "zod") dirs.add(abs(g.path ?? "src/validators/zod"));
+    if (g.kind === "valibot") dirs.add(abs(g.path ?? "src/validators/valibot"));
+    if (g.kind === "arktype") dirs.add(abs(g.path ?? "src/validators/arktype"));
+    if (g.kind === "typebox") dirs.add(abs(g.path ?? "src/validators/typebox"));
+    if (g.kind === "effect") dirs.add(abs(g.path ?? "src/validators/effect"));
+    if (g.kind === "json-schema") dirs.add(abs(g.path ?? "src/validators/json-schema"));
+  }
+  return [...dirs];
+}
+function resolveTemplateDirsSync(cfg, cwd = process.cwd()) {
+  const results = [];
+  const req = createRequire(
+    typeof __filename !== "undefined" ? __filename : path.join(process.cwd(), "index.js")
+  );
+  for (const g of cfg.generators) {
+    const t = g.template;
+    if (!t || t === "standard" || t === "minimal" || t === "service") continue;
+    let pkgDir = null;
+    try {
+      const pkg = req.resolve(`${t}/package.json`, { paths: [cwd] });
+      pkgDir = path.dirname(pkg);
+    } catch {
+    }
+    if (pkgDir) {
+      results.push(pkgDir);
+      continue;
+    }
+    if (/[./\\]/.test(t)) {
+      const abs = path.resolve(cwd, t);
+      if (fs.existsSync(abs)) results.push(abs);
+    }
+  }
+  return Array.from(new Set(results));
+}
+function filterTables(tables, opts) {
+  let out = tables;
+  if (opts.include?.length) out = out.filter((t) => matchesTable(opts.include, t));
+  if (opts.exclude?.length) out = out.filter((t) => !matchesTable(opts.exclude, t));
+  return out;
+}
+function tableFilterWarnings(tables, opts) {
+  return [
+    ...ambiguousPatternWarnings(opts.include ?? [], tables, "include"),
+    ...ambiguousPatternWarnings(opts.exclude ?? [], tables, "exclude")
+  ];
+}
+function computeWatchTargets(cfg, cwd = process.cwd(), source) {
+  const abs = (p) => path.resolve(cwd, p);
+  const targets = new Set(CONFIG_FILE_NAMES.map(abs));
+  if (source) {
+    for (const d of source.watchDirs) targets.add(abs(d));
+    if (source.drizzleKitConfigPath) targets.add(abs(source.drizzleKitConfigPath));
+  } else if (cfg.schema) {
+    targets.add(path.dirname(abs(cfg.schema)));
+  }
+  for (const t of resolveTemplateDirsSync(cfg, cwd)) targets.add(t);
+  return [...targets];
+}
+
+export {
+  ConfigValidationError,
+  nearestKey,
+  matchesAny,
+  tableAliases,
+  matchesTable,
+  displayTableName,
+  addressableName,
+  hasNamedSchemas,
+  ambiguousPatternWarnings,
+  NamingSchema,
+  AffixSchema,
+  ImportExtensionSchema,
+  GeneratorKindSchema,
+  GENERATOR_KINDS,
+  GeneratorSchema,
+  ColumnRulesSchema,
+  AnalyzerSchema,
+  ConfigSchema,
+  defineConfig,
+  CONFIG_FILE_NAMES,
+  CONFIG_SCHEMA_ID,
+  buildConfigJsonSchema,
+  trpcOutDir,
+  honoOutDir,
+  expressOutDir,
+  fastifyOutDir,
+  nestjsOutDir,
+  graphqlOutDir,
+  resolveConfig,
+  importFreshConfigModule,
+  loadConfig,
+  configFromKinds,
+  computeGeneratorOutputDirs,
+  resolveTemplateDirsSync,
+  filterTables,
+  tableFilterWarnings,
+  computeWatchTargets
+};
+//# sourceMappingURL=chunk-54E2IO7N.js.map