@drzl/cli 4.19.0 → 4.23.0

package/dist/config.cjs

@@ -33,17 +33,31 @@ var config_exports = {};
 __export(config_exports, {
   AffixSchema: () => AffixSchema,
   AnalyzerSchema: () => AnalyzerSchema,
+  CONFIG_FILE_NAMES: () => CONFIG_FILE_NAMES,
+  CONFIG_SCHEMA_ID: () => CONFIG_SCHEMA_ID,
+  ColumnRulesSchema: () => ColumnRulesSchema,
   ConfigSchema: () => ConfigSchema,
+  GENERATOR_KINDS: () => GENERATOR_KINDS,
+  GeneratorKindSchema: () => GeneratorKindSchema,
   GeneratorSchema: () => GeneratorSchema,
   ImportExtensionSchema: () => ImportExtensionSchema,
   NamingSchema: () => NamingSchema,
+  buildConfigJsonSchema: () => buildConfigJsonSchema,
   computeGeneratorOutputDirs: () => computeGeneratorOutputDirs,
   computeWatchTargets: () => computeWatchTargets,
+  configFromKinds: () => configFromKinds,
   defineConfig: () => defineConfig,
+  expressOutDir: () => expressOutDir,
+  fastifyOutDir: () => fastifyOutDir,
   filterTables: () => filterTables,
+  graphqlOutDir: () => graphqlOutDir,
+  honoOutDir: () => honoOutDir,
+  importFreshConfigModule: () => importFreshConfigModule,
   loadConfig: () => loadConfig,
+  nestjsOutDir: () => nestjsOutDir,
   resolveConfig: () => resolveConfig,
   resolveTemplateDirsSync: () => resolveTemplateDirsSync,
+  tableFilterWarnings: () => tableFilterWarnings,
   trpcOutDir: () => trpcOutDir
 });
 module.exports = __toCommonJS(config_exports);
@@ -52,17 +66,253 @@ var fs = __toESM(require("fs"), 1);
 var import_node_module = require("module");
 var path = __toESM(require("path"), 1);
 var import_zod = require("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 addressableName(table) {
+  return `${table.schema ?? DEFAULT_SCHEMA_ALIAS}.${table.name}`;
+}
+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 = import_zod.z.object({
   routerSuffix: import_zod.z.string().default("Router"),
   procedureCase: import_zod.z.enum(["camel", "kebab", "snake"]).default("camel")
 }).partial();
-var AffixValueSchema = import_zod.z.union(
+var affixValueSchema = (pattern) => import_zod.z.union(
   [
-    import_zod.z.string(),
+    import_zod.z.string().meta({ pattern }),
     import_zod.z.object({
-      insert: import_zod.z.string().optional(),
-      update: import_zod.z.string().optional(),
-      select: import_zod.z.string().optional()
+      insert: import_zod.z.string().meta({ pattern }).optional(),
+      update: import_zod.z.string().meta({ pattern }).optional(),
+      select: import_zod.z.string().meta({ pattern }).optional()
     }).strict()
   ],
   {
@@ -70,8 +320,8 @@ var AffixValueSchema = import_zod.z.union(
   }
 );
 var AffixPartSchema = import_zod.z.object({
-  prefix: AffixValueSchema.optional(),
-  suffix: AffixValueSchema.optional()
+  prefix: affixValueSchema(import_validation_core.AFFIX_PREFIX_PATTERN).optional(),
+  suffix: affixValueSchema(import_validation_core.AFFIX_SUFFIX_PATTERN).optional()
 }).strict();
 var AffixSchema = import_zod.z.object({
   /**
@@ -84,18 +334,34 @@ var AffixSchema = import_zod.z.object({
   type: AffixPartSchema.optional()
 }).strict();
 var ImportExtensionSchema = import_zod.z.enum(import_validation_core.IMPORT_EXTENSIONS);
+var GeneratorKindSchema = import_zod.z.enum([
+  "orpc",
+  "trpc",
+  "hono",
+  "express",
+  "fastify",
+  "nestjs",
+  "graphql",
+  "service",
+  "zod",
+  "valibot",
+  "arktype",
+  "typebox",
+  "effect",
+  "json-schema"
+]);
+var GENERATOR_KINDS = GeneratorKindSchema.options;
 var GeneratorSchema = import_zod.z.object({
-  kind: import_zod.z.enum([
-    "orpc",
-    "trpc",
-    "service",
-    "zod",
-    "valibot",
-    "arktype",
-    "typebox",
-    "effect",
-    "json-schema"
-  ]),
+  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: import_zod.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.
@@ -103,6 +369,17 @@ var GeneratorSchema = import_zod.z.object({
   importExtension: ImportExtensionSchema.optional(),
   template: import_zod.z.string().optional(),
   includeRelations: import_zod.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: import_zod.z.boolean().optional(),
   /**
    * Type `json` and `jsonb` columns from the schema rather than leaving them wide.
    *
@@ -131,6 +408,57 @@ var GeneratorSchema = import_zod.z.object({
    * fact about the table rather than the row. This checks the half that needs no database.
    */
   duplicateFinder: import_zod.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: import_zod.z.union([
+    import_zod.z.boolean(),
+    import_zod.z.object({ enabled: import_zod.z.boolean().optional(), errorMap: import_zod.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: import_zod.z.union([
+    import_zod.z.boolean(),
+    import_zod.z.object({ enabled: import_zod.z.boolean().optional(), description: import_zod.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: import_zod.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.
@@ -147,6 +475,29 @@ var GeneratorSchema = import_zod.z.object({
    * it is also what terminates a cycle: `users -> posts -> users` stops here.
    */
   nestedDepth: import_zod.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: import_zod.z.union([
+    import_zod.z.boolean(),
+    import_zod.z.object({
+      enabled: import_zod.z.boolean().optional(),
+      foreignKeys: import_zod.z.boolean().optional(),
+      aliases: import_zod.z.boolean().optional()
+    }).strict()
+  ]).optional(),
   naming: NamingSchema.optional(),
   outputHeader: import_zod.z.object({
     enabled: import_zod.z.boolean().default(true).optional(),
@@ -241,13 +592,41 @@ var GeneratorSchema = import_zod.z.object({
   // template options
   templateOptions: import_zod.z.record(import_zod.z.string(), import_zod.z.any()).optional()
 });
+var ColumnRulesSchema = import_zod.z.object({
+  omit: import_zod.z.array(import_zod.z.string()).optional(),
+  pick: import_zod.z.array(import_zod.z.string()).optional()
+}).strict();
 var AnalyzerSchema = import_zod.z.object({
   includeRelations: import_zod.z.boolean().default(true),
   validateConstraints: import_zod.z.boolean().default(true),
   includeHeuristicRelations: import_zod.z.boolean().default(false)
 });
 var ConfigSchema = import_zod.z.object({
-  schema: import_zod.z.string(),
+  /**
+   * 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: import_zod.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: import_zod.z.union([import_zod.z.boolean(), import_zod.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: import_zod.z.string().default("src/api"),
   /**
    * Which tables to generate for, matched against the database table name.
@@ -267,6 +646,37 @@ var ConfigSchema = import_zod.z.object({
    */
   include: import_zod.z.array(import_zod.z.string()).optional(),
   exclude: import_zod.z.array(import_zod.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: import_zod.z.record(import_zod.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
@@ -301,10 +711,58 @@ var ConfigSchema = import_zod.z.object({
 function defineConfig(cfg) {
   return cfg;
 }
-var ROUTER_KINDS = /* @__PURE__ */ new Set(["orpc", "trpc"]);
+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 = import_zod.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 = (0, import_validation_core.resolveAffix)(opts);
   return import_validation_core.NAME_MODES.map((mode) => (0, import_validation_core.schemaName)(mode, import_validation_core.AFFIX_PROBE_TABLE, resolved));
@@ -316,8 +774,66 @@ function resolveConfig(cfg) {
     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) {
+    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;
@@ -374,20 +890,58 @@ function resolveConfig(cfg) {
   }
   return { config: { ...cfg, generators }, warnings };
 }
-function finalize(raw) {
-  const { config, warnings } = resolveConfig(ConfigSchema.parse(raw));
-  for (const w of warnings) console.warn(w);
+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 loadConfig(customPath) {
+async function importFreshConfigModule(p) {
   const fsp = await import("fs/promises");
-  const candidates = customPath ? [customPath] : [
-    "drzl.config.ts",
-    "drzl.config.mjs",
-    "drzl.config.js",
-    "drzl.config.cjs",
-    "drzl.config.json"
-  ];
+  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 {
@@ -395,38 +949,31 @@ async function loadConfig(customPath) {
     } catch {
       continue;
     }
-    const ext = path.extname(p).toLowerCase();
-    if (ext === ".json") {
-      const raw2 = JSON.parse(await fsp.readFile(p, "utf8"));
-      return finalize(raw2);
-    }
-    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);
-    const raw = mod?.default ?? mod;
-    return finalize(raw);
+    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"));
@@ -463,25 +1010,26 @@ function resolveTemplateDirsSync(cfg, cwd = process.cwd()) {
   return Array.from(new Set(results));
 }
 function filterTables(tables, opts) {
-  const toRegExp = (pattern) => new RegExp(
-    "^" + pattern.split("*").map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join(".*") + "$"
-  );
-  const matches = (patterns, name) => patterns.some((p) => toRegExp(p).test(name));
   let out = tables;
-  if (opts.include?.length) out = out.filter((t) => matches(opts.include, t.name));
-  if (opts.exclude?.length) out = out.filter((t) => !matches(opts.exclude, t.name));
+  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 computeWatchTargets(cfg, cwd = process.cwd()) {
+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 schemaAbs = abs(cfg.schema);
-  const targets = /* @__PURE__ */ new Set([
-    path.dirname(schemaAbs),
-    abs("drzl.config.ts"),
-    abs("drzl.config.js"),
-    abs("drzl.config.mjs"),
-    abs("drzl.config.cjs")
-  ]);
+  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];
 }
@@ -489,17 +1037,31 @@ function computeWatchTargets(cfg, cwd = process.cwd()) {
 0 && (module.exports = {
   AffixSchema,
   AnalyzerSchema,
+  CONFIG_FILE_NAMES,
+  CONFIG_SCHEMA_ID,
+  ColumnRulesSchema,
   ConfigSchema,
+  GENERATOR_KINDS,
+  GeneratorKindSchema,
   GeneratorSchema,
   ImportExtensionSchema,
   NamingSchema,
+  buildConfigJsonSchema,
   computeGeneratorOutputDirs,
   computeWatchTargets,
+  configFromKinds,
   defineConfig,
+  expressOutDir,
+  fastifyOutDir,
   filterTables,
+  graphqlOutDir,
+  honoOutDir,
+  importFreshConfigModule,
   loadConfig,
+  nestjsOutDir,
   resolveConfig,
   resolveTemplateDirsSync,
+  tableFilterWarnings,
   trpcOutDir
 });
 //# sourceMappingURL=config.cjs.map