@drzl/cli 4.21.0 → 4.24.0

package/dist/{chunk-XNNKHBGV.js → chunk-54E2IO7N.js}

@@ -1,6 +1,8 @@
 // src/config.ts
 import {
+  AFFIX_PREFIX_PATTERN,
   AFFIX_PROBE_TABLE,
+  AFFIX_SUFFIX_PATTERN,
   DEFAULT_IMPORT_EXTENSION,
   IMPORT_EXTENSIONS,
   NAME_MODES,
@@ -13,6 +15,207 @@ 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(
@@ -57,13 +260,13 @@ var NamingSchema = z.object({
   routerSuffix: z.string().default("Router"),
   procedureCase: z.enum(["camel", "kebab", "snake"]).default("camel")
 }).partial();
-var AffixValueSchema = z.union(
+var affixValueSchema = (pattern) => z.union(
   [
-    z.string(),
+    z.string().meta({ pattern }),
     z.object({
-      insert: z.string().optional(),
-      update: z.string().optional(),
-      select: z.string().optional()
+      insert: z.string().meta({ pattern }).optional(),
+      update: z.string().meta({ pattern }).optional(),
+      select: z.string().meta({ pattern }).optional()
     }).strict()
   ],
   {
@@ -71,8 +274,8 @@ var AffixValueSchema = z.union(
   }
 );
 var AffixPartSchema = z.object({
-  prefix: AffixValueSchema.optional(),
-  suffix: AffixValueSchema.optional()
+  prefix: affixValueSchema(AFFIX_PREFIX_PATTERN).optional(),
+  suffix: affixValueSchema(AFFIX_SUFFIX_PATTERN).optional()
 }).strict();
 var AffixSchema = z.object({
   /**
@@ -85,18 +288,34 @@ var AffixSchema = z.object({
   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: 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: 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.
@@ -104,6 +323,17 @@ var GeneratorSchema = z.object({
   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.
    *
@@ -132,6 +362,27 @@ var GeneratorSchema = z.object({
    * 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
@@ -305,7 +556,31 @@ var AnalyzerSchema = z.object({
   includeHeuristicRelations: z.boolean().default(false)
 });
 var ConfigSchema = z.object({
-  schema: 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: 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.
@@ -390,10 +665,58 @@ var ConfigSchema = 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 = 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));
@@ -405,8 +728,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;
@@ -463,20 +844,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 {
@@ -484,38 +903,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"));
@@ -563,22 +975,24 @@ function tableFilterWarnings(tables, opts) {
     ...ambiguousPatternWarnings(opts.exclude ?? [], tables, "exclude")
   ];
 }
-function computeWatchTargets(cfg, cwd = process.cwd()) {
+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];
 }
 
 export {
+  ConfigValidationError,
+  nearestKey,
   matchesAny,
+  tableAliases,
   matchesTable,
   displayTableName,
   addressableName,
@@ -587,18 +1001,30 @@ export {
   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-XNNKHBGV.js.map
+//# sourceMappingURL=chunk-54E2IO7N.js.map