@drzl/cli 4.13.0 → 4.14.0

package/dist/{chunk-ZYJ4I2I7.js → chunk-HGD5CBM5.js}

@@ -73,6 +73,14 @@ var GeneratorSchema = z.object({
   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(),
   naming: NamingSchema.optional(),
   outputHeader: z.object({
     enabled: z.boolean().default(true).optional(),
@@ -93,6 +101,8 @@ var GeneratorSchema = z.object({
    * 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(),
   // service generator specific options
   path: z.string().optional(),
   dataAccess: z.enum(["stub", "drizzle"]).default("stub").optional(),
@@ -359,4 +369,4 @@ export {
   filterTables,
   computeWatchTargets
 };
-//# sourceMappingURL=chunk-ZYJ4I2I7.js.map
+//# sourceMappingURL=chunk-HGD5CBM5.js.map

package/dist/chunk-HGD5CBM5.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/config.ts"],"sourcesContent":["import type { AffixOptions } from '@drzl/validation-core';\nimport {\n  AFFIX_PROBE_TABLE,\n  DEFAULT_IMPORT_EXTENSION,\n  IMPORT_EXTENSIONS,\n  NAME_MODES,\n  resolveAffix,\n  schemaName,\n  validateAffix,\n} from '@drzl/validation-core';\nimport * as fs from 'node:fs';\nimport { createRequire } from 'node:module';\nimport * as path from 'node:path';\nimport { z } from 'zod';\n\nexport const NamingSchema = z\n  .object({\n    routerSuffix: z.string().default('Router'),\n    procedureCase: z.enum(['camel', 'kebab', 'snake']).default('camel'),\n  })\n  .partial();\n\n/** One affix for every mode, or a per-mode map. Keys match drzl's internal mode names. */\nconst AffixValueSchema = z.union(\n  [\n    z.string(),\n    z\n      .object({\n        insert: z.string().optional(),\n        update: z.string().optional(),\n        select: z.string().optional(),\n      })\n      .strict(),\n  ],\n  {\n    error:\n      'Expected a string to use for every mode, or an object with any of the keys \"insert\", ' +\n      '\"update\" and \"select\". Those keys are lowercase, matching the mode names drzl uses ' +\n      'everywhere else.',\n  }\n);\n\nconst AffixPartSchema = z\n  .object({\n    prefix: AffixValueSchema.optional(),\n    suffix: AffixValueSchema.optional(),\n  })\n  .strict();\n\nexport const AffixSchema = z\n  .object({\n    /**\n     * `preserve` (default) keeps today's output: the Drizzle export name goes into the\n     * identifier verbatim, so `export const users` yields `InsertusersSchema`. `pascal`\n     * upper-camels it first, yielding `InsertUsersSchema`.\n     */\n    tableCase: z.enum(['preserve', 'pascal']).optional(),\n    schema: AffixPartSchema.optional(),\n    type: AffixPartSchema.optional(),\n  })\n  .strict();\n\n/**\n * How every relative specifier drzl invents spells its extension.\n *\n * The generated files land in the consumer's own source tree, so the consumer's\n * `moduleResolution` decides which forms resolve. `js` is the only one that resolves under\n * all of `bundler`, `node10`, `node16` and `nodenext` with no compiler flag, so it is the\n * default. See the `ImportExtension` docs in `@drzl/validation-core` for the measured grid.\n */\nexport const ImportExtensionSchema = z.enum(IMPORT_EXTENSIONS);\n\nexport const GeneratorSchema = z.object({\n  kind: z.enum(['orpc', 'service', 'zod', 'valibot', 'arktype', 'typebox', 'json-schema']),\n  /**\n   * Overrides the top-level `importExtension` for this generator alone, for a project whose\n   * generated directories are compiled by different tsconfigs.\n   */\n  importExtension: ImportExtensionSchema.optional(),\n  template: z.string().optional(),\n  includeRelations: z.boolean().optional(),\n  /**\n   * Type `json` and `jsonb` columns from the schema rather than leaving them wide.\n   *\n   * `.$type<T>()` is a compile-time cast, so no runtime-derived validator can see it and\n   * `drizzle-orm/zod` types every json column as its generic `Json`. A generator can reference\n   * `typeof <table>.$inferSelect['<column>']` instead, which is the declared type resolved by\n   * TypeScript itself, so generics, unions and imported interfaces all work.\n   *\n   * Off by default because it makes the generated file import your schema module, as a\n   * type-only import that disappears at build time.\n   */\n  // What a date column accepts. Documented on the zod generator and, until now, accepted by the\n  // config parser and then dropped on the floor: the generators default it to 'input' themselves,\n  // so setting it here changed nothing.\n  coerceDates: z.enum(['input', 'all', 'none']).optional(),\n  typedJson: z.boolean().optional(),\n  // The wider form: every column's static type comes from Drizzle, not just the untyped ones.\n  typedColumns: z.boolean().optional(),\n  // Reproduce literal column defaults in the insert schema, so parsing fills them in.\n  applyDefaults: z.boolean().optional(),\n  /**\n   * Emit `findDuplicate<Table>` beside the schemas: the rows in a batch that collide with an\n   * earlier row on a unique constraint.\n   *\n   * Uniqueness is the one constraint a per-row validator structurally cannot see, since it is a\n   * fact about the table rather than the row. This checks the half that needs no database.\n   */\n  duplicateFinder: z.boolean().optional(),\n  naming: NamingSchema.optional(),\n  outputHeader: z\n    .object({\n      enabled: z.boolean().default(true).optional(),\n      text: z.string().optional(),\n    })\n    .optional(),\n  format: z\n    .object({\n      enabled: z.boolean().default(true).optional(),\n      engine: z.enum(['auto', 'prettier', 'biome']).default('auto').optional(),\n      configPath: z.string().optional(),\n    })\n    .optional(),\n  /**\n   * Which spelling of JSON Schema the `json-schema` generator emits.\n   *\n   * OpenAPI 3.0 is not an older superset of the 2020-12 draft, it is a different dialect: a\n   * nullable type is `nullable: true` rather than a type array, and an exclusive bound is a\n   * boolean flag beside the bound rather than its own keyword. An unknown keyword is not an error\n   * in JSON Schema, it is ignored, so emitting the wrong dialect produces a document that\n   * validates and then accepts the values the constraints exist to reject.\n   */\n  target: z.enum(['draft-2020-12', 'openapi-3.1', 'openapi-3.0']).optional(),\n  /** Also emit `components.ts` for the `json-schema` generator, ready for an OpenAPI document. */\n  components: z.boolean().optional(),\n  // service generator specific options\n  path: z.string().optional(),\n  dataAccess: z.enum(['stub', 'drizzle']).default('stub').optional(),\n  dbImportPath: z.string().optional(),\n  schemaImportPath: z.string().optional(),\n  // zod/valibot/arktype generator specific options\n  schemaSuffix: z.string().optional(),\n  fileSuffix: z.string().optional(),\n  /**\n   * Prefixes, suffixes and table casing for generated identifiers (zod/valibot/arktype).\n   * Omitting it reproduces the output of every previous release exactly.\n   */\n  affix: AffixSchema.optional(),\n  // orpc validation sharing\n  validation: z\n    .object({\n      useShared: z.boolean().default(false).optional(),\n      library: z.enum(['zod', 'valibot', 'arktype']).default('zod').optional(),\n      importPath: z.string().optional(),\n      schemaSuffix: z.string().optional(),\n      /**\n       * How the validation generator named its exports. Usually left unset: the CLI copies\n       * it from the sibling generator whose `kind` matches `library`.\n       */\n      affix: AffixSchema.optional(),\n    })\n    .optional(),\n  // template options\n  templateOptions: z.record(z.string(), z.any()).optional(),\n});\n\nexport const AnalyzerSchema = z.object({\n  includeRelations: z.boolean().default(true),\n  validateConstraints: z.boolean().default(true),\n  includeHeuristicRelations: z.boolean().default(false),\n});\n\nexport const ConfigSchema = z\n  .object({\n    schema: z.string(),\n    outDir: z.string().default('src/api'),\n    /**\n     * Which tables to generate for, matched against the database table name.\n     *\n     * There was no way to say this, and every generator loops over every table it finds, so\n     * DRZL emitted unauthenticated CRUD over whatever shared the schema file. That is noise for\n     * a migrations table and a genuine leak for an auth one: Better Auth puts `user`, `session`,\n     * `account` and `verification` alongside your own tables, and `account` holds\n     * `accessToken`, `refreshToken`, `idToken` and `password`.\n     *\n     * Deliberately name-based and explicit rather than detecting any particular library. Auth\n     * table names are all renameable, so a built-in list would miss renamed tables and, worse,\n     * silently skip an ordinary table that happened to be called `user`, which is usually the\n     * application's main entity.\n     *\n     * `exclude` wins over `include`. Patterns support `*`, matching within a name.\n     */\n    include: z.array(z.string()).optional(),\n    exclude: z.array(z.string()).optional(),\n    /**\n     * How every relative specifier drzl invents spells its extension, for every generator.\n     * A generator may override it. Defaults to `js`, which is the only form that resolves\n     * under every `moduleResolution` without a compiler flag.\n     */\n    importExtension: ImportExtensionSchema.default(DEFAULT_IMPORT_EXTENSION),\n    analyzer: AnalyzerSchema.default({\n      includeRelations: true,\n      validateConstraints: true,\n      includeHeuristicRelations: false,\n    }),\n    generators: z\n      .array(GeneratorSchema)\n      .min(1)\n      .default([{ kind: 'orpc' } as any]),\n  })\n  // Reject an affix before anything is written, rather than emitting a file that cannot\n  // compile. Only `affix` is inspected; the legacy flat `schemaSuffix` is left alone so\n  // configs that parse today keep parsing.\n  .superRefine((cfg, ctx) => {\n    cfg.generators.forEach((g, i) => {\n      const report = (base: (string | number)[], affix?: AffixOptions, schemaSuffix?: string) => {\n        for (const issue of validateAffix(affix, schemaSuffix)) {\n          ctx.addIssue({\n            code: 'custom',\n            path: ['generators', i, ...base, ...issue.path],\n            message: issue.message,\n          });\n        }\n      };\n      report(['affix'], g.affix as AffixOptions | undefined, g.schemaSuffix);\n      report(\n        ['validation', 'affix'],\n        g.validation?.affix as AffixOptions | undefined,\n        g.validation?.schemaSuffix\n      );\n    });\n  });\n\n// ✨ Separate input vs output types\nexport type DrzlConfigInput = z.input<typeof ConfigSchema>;\nexport type DrzlConfig = z.output<typeof ConfigSchema>;\n\nexport function defineConfig<T extends DrzlConfigInput>(cfg: T): T {\n  return cfg;\n}\n\ntype GeneratorConfig = DrzlConfig['generators'][number];\n\nfunction sharedSchemaNames(opts: { affix?: AffixOptions; schemaSuffix?: string }): string[] {\n  const resolved = resolveAffix(opts);\n  return NAME_MODES.map((mode) => schemaName(mode, AFFIX_PROBE_TABLE, resolved));\n}\n\n/**\n * Fill in cross-generator defaults and refuse configs whose generators would disagree.\n *\n * An oRPC router that imports shared schemas has to spell the exact names the validation\n * generator exported. Both sides used to be configured independently, so they could silently\n * drift into a router that does not compile. When an oRPC generator uses shared validation\n * and exactly one sibling generator produces that library, its `affix` is copied across.\n *\n * Deliberately conservative about the pre-existing flat `schemaSuffix`: a disagreement there\n * is only reported, never repaired, because repairing it would change the bytes an existing\n * config emits.\n *\n * `importExtension` is pushed down here too. A consumer compiles the whole generated tree\n * with one tsconfig, so the setting that has to hold is the same for every generator, and\n * every call site downstream can then read it off the generator without knowing about the\n * top-level default.\n */\nexport function resolveConfig(cfg: DrzlConfig): { config: DrzlConfig; warnings: string[] } {\n  const warnings: string[] = [];\n  const generators: GeneratorConfig[] = cfg.generators.map((g) => ({\n    ...g,\n    importExtension: g.importExtension ?? cfg.importExtension,\n  }));\n\n  for (const g of generators) {\n    if (g.kind !== 'orpc') continue;\n    const v = g.validation;\n    if (!v?.useShared) continue;\n\n    const library = v.library ?? 'zod';\n    const siblings = generators.filter((s) => s.kind === library);\n    // Zero siblings means the user points at a barrel drzl does not generate; more than one\n    // means there is no single source of truth. Either way, leave the config alone.\n    if (siblings.length !== 1) continue;\n    const sibling = siblings[0];\n\n    const theirs = sharedSchemaNames({\n      affix: sibling.affix as AffixOptions | undefined,\n      schemaSuffix: sibling.schemaSuffix,\n    });\n\n    if (!v.affix) {\n      if (sibling.affix) {\n        // Bake the sibling's fully resolved naming in, so its own schemaSuffix fallback\n        // travels with it and cannot be re-interpreted on the oRPC side.\n        g.validation = {\n          ...v,\n          affix: resolveAffix({\n            affix: sibling.affix as AffixOptions,\n            schemaSuffix: sibling.schemaSuffix,\n          }),\n        };\n        continue;\n      }\n      const mine = sharedSchemaNames({ schemaSuffix: v.schemaSuffix });\n      if (mine.join(',') !== theirs.join(',')) {\n        warnings.push(\n          `drzl config: the \"orpc\" generator's validation.schemaSuffix ` +\n            `(${JSON.stringify(v.schemaSuffix ?? 'Schema')}) does not match the \"${library}\" ` +\n            `generator's schemaSuffix (${JSON.stringify(sibling.schemaSuffix ?? 'Schema')}). ` +\n            `The router will import ${mine.join(', ')} but the \"${library}\" generator exports ` +\n            `${theirs.join(', ')}, so the generated router will not compile. Set both to the ` +\n            `same value, or move to \"affix\", which is inherited automatically.`\n        );\n      }\n      continue;\n    }\n\n    const mine = sharedSchemaNames({\n      affix: v.affix as AffixOptions,\n      schemaSuffix: v.schemaSuffix,\n    });\n    if (mine.join(',') !== theirs.join(',')) {\n      throw new Error(\n        `drzl config: the \"orpc\" generator imports shared ${library} schemas, but its ` +\n          `validation.affix disagrees with the \"${library}\" generator's own naming. The router ` +\n          `would import ${mine.join(', ')} while the \"${library}\" generator exports ` +\n          `${theirs.join(', ')}. Make them match, or drop validation.affix and let it be ` +\n          `inherited from the \"${library}\" generator.`\n      );\n    }\n  }\n\n  return { config: { ...cfg, generators }, warnings };\n}\n\n/**\n * Parse, then resolve cross-generator defaults. Both `generate` and `watch` go through\n * loadConfig, so putting the resolution here is what keeps the two duplicated generator\n * dispatch blocks in cli.ts from needing the logic twice.\n */\nfunction finalize(raw: unknown): DrzlConfig {\n  const { config, warnings } = resolveConfig(ConfigSchema.parse(raw));\n  for (const w of warnings) console.warn(w);\n  return config;\n}\n\nexport async function loadConfig(customPath?: string): Promise<DrzlConfig | null> {\n  const fsp = await import('node:fs/promises');\n\n  const candidates = customPath\n    ? [customPath]\n    : [\n        'drzl.config.ts',\n        'drzl.config.mjs',\n        'drzl.config.js',\n        'drzl.config.cjs',\n        'drzl.config.json',\n      ];\n\n  for (const c of candidates) {\n    const p = path.resolve(process.cwd(), c);\n    try {\n      await fsp.access(p);\n    } catch {\n      continue;\n    }\n\n    const ext = path.extname(p).toLowerCase();\n\n    // JSON: read directly\n    if (ext === '.json') {\n      const raw = JSON.parse(await fsp.readFile(p, 'utf8'));\n      return finalize(raw);\n    }\n\n    // Everything else (TS/JS/MJS/CJS) -> Jiti with cache-busting\n    const { createJiti } = await import('jiti');\n    const stat = await fsp.stat(p);\n\n    // Passing __filename is safe in CJS; fallback to cwd if not defined.\n    const base =\n      typeof __filename !== 'undefined' ? __filename : path.join(process.cwd(), 'index.js');\n\n    const jiti = createJiti(base, {\n      moduleCache: false, // re-evaluate each time\n      fsCache: true, // keep transform cache\n      cacheVersion: String(stat.mtimeMs), // bump on edit\n      interopDefault: true,\n      tryNative: false, // <-- prevent native import of .ts\n      // debug: true,\n    }) as any;\n\n    const mod = await jiti.import(p);\n    const raw = mod?.default ?? mod;\n    return finalize(raw);\n  }\n\n  return null;\n}\n\n/** Absolute output dirs for all generators (to ignore in watcher). */\nexport function computeGeneratorOutputDirs(cfg: DrzlConfig, cwd = process.cwd()): string[] {\n  const abs = (p: string) => path.resolve(cwd, p);\n  const dirs = new Set<string>();\n  dirs.add(abs(cfg.outDir)); // orpc\n  for (const g of cfg.generators) {\n    if (g.kind === 'service') dirs.add(abs(g.path ?? 'src/services'));\n    if (g.kind === 'zod') dirs.add(abs(g.path ?? 'src/validators/zod'));\n    if (g.kind === 'valibot') dirs.add(abs(g.path ?? 'src/validators/valibot'));\n    if (g.kind === 'arktype') dirs.add(abs(g.path ?? 'src/validators/arktype'));\n    if (g.kind === 'typebox') dirs.add(abs(g.path ?? 'src/validators/typebox'));\n    if (g.kind === 'json-schema') dirs.add(abs(g.path ?? 'src/validators/json-schema'));\n  }\n  return [...dirs];\n}\n\n/** Resolve custom template directories (local path or installed package). */\nexport function resolveTemplateDirsSync(cfg: DrzlConfig, cwd = process.cwd()): string[] {\n  const results: string[] = [];\n  const req = createRequire(\n    typeof __filename !== 'undefined' ? __filename : path.join(process.cwd(), 'index.js')\n  );\n\n  for (const g of cfg.generators) {\n    const t = g.template;\n    if (!t || t === 'standard' || t === 'minimal') continue;\n\n    // Try package resolution relative to cwd\n    let pkgDir: string | null = null;\n    try {\n      const pkg = req.resolve(`${t}/package.json`, { paths: [cwd] as any });\n      pkgDir = path.dirname(pkg);\n    } catch {}\n\n    if (pkgDir) {\n      results.push(pkgDir);\n      continue;\n    }\n\n    // Local path-like template\n    if (/[./\\\\]/.test(t)) {\n      const abs = path.resolve(cwd, t);\n      if (fs.existsSync(abs)) results.push(abs);\n    }\n  }\n\n  return Array.from(new Set(results));\n}\n\n/** Build watch targets (exclude output dirs; watcher will ignore those). */\n/**\n * Narrow an analysis's tables to the ones the config asked for.\n *\n * Matching is on the database table name, anchored, with `*` as the only metacharacter. Anchored\n * matters: `user` must not also drop `users`, and a substring match would. `exclude` is applied\n * after `include`, so the safer direction wins when both name the same table.\n */\nexport function filterTables<T extends { name: string }>(\n  tables: T[],\n  opts: { include?: string[]; exclude?: string[] }\n): T[] {\n  const toRegExp = (pattern: string) =>\n    new RegExp(\n      '^' +\n        pattern\n          .split('*')\n          .map((part) => part.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&'))\n          .join('.*') +\n        '$'\n    );\n\n  const matches = (patterns: string[], name: string) =>\n    patterns.some((p) => toRegExp(p).test(name));\n\n  let out = tables;\n  if (opts.include?.length) out = out.filter((t) => matches(opts.include!, t.name));\n  if (opts.exclude?.length) out = out.filter((t) => !matches(opts.exclude!, t.name));\n  return out;\n}\n\nexport function computeWatchTargets(cfg: DrzlConfig, cwd = process.cwd()): string[] {\n  const abs = (p: string) => path.resolve(cwd, p);\n  const schemaAbs = abs(cfg.schema);\n  // The schema's directory, not a glob under it. Chokidar removed glob support in v4 and treats\n  // `<dir>/**/*.{ts,tsx,js}` as a literal path, so it watched a directory named `**` that does\n  // not exist: no event ever fired and `drzl watch` did its initial build and then sat inert.\n  // A directory is watched recursively by chokidar itself, and the extension filtering that the\n  // glob was doing now happens on the event instead.\n  const targets = new Set<string>([\n    path.dirname(schemaAbs),\n    abs('drzl.config.ts'),\n    abs('drzl.config.js'),\n    abs('drzl.config.mjs'),\n    abs('drzl.config.cjs'),\n  ]);\n  for (const t of resolveTemplateDirsSync(cfg, cwd)) targets.add(t);\n  return [...targets];\n}\n"],"mappings":"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","names":["mine","raw"]}

package/dist/cli.cjs

@@ -6,6 +6,13 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -23,6 +30,313 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// ../generator-json-schema/dist/index.js
+var dist_exports = {};
+__export(dist_exports, {
+  JsonSchemaGenerator: () => JsonSchemaGenerator,
+  componentsDocument: () => componentsDocument,
+  default: () => index_default,
+  tableSchemas: () => tableSchemas
+});
+function baseSchema(c, mode, target, checks, sets, lengths) {
+  const s = c.shape;
+  if (s) {
+    switch (s.kind) {
+      case "json":
+        return {};
+      case "custom":
+        return {};
+      case "buffer":
+        return { type: "string", contentEncoding: "base64" };
+      case "tuple":
+        return target === "openapi-3.0" ? { type: "array", items: { type: "number" }, minItems: s.length, maxItems: s.length } : {
+          type: "array",
+          prefixItems: Array.from({ length: s.length }, () => ({ type: "number" })),
+          minItems: s.length,
+          maxItems: s.length
+        };
+      case "numberVector":
+        return {
+          type: "array",
+          items: { type: "number" },
+          ...s.length ? { minItems: s.length, maxItems: s.length } : {}
+        };
+      case "bitstring":
+        return {
+          type: "string",
+          pattern: "^[01]*$",
+          ...s.length ? s.exact ? { minLength: s.length, maxLength: s.length } : { maxLength: s.length } : {}
+        };
+    }
+  }
+  const set = sets.find((x) => x.column === c.name);
+  if (set) return { enum: set.values.map((v) => set.kind === "string" ? v : Number(v)) };
+  if (c.enumValues && c.enumValues.length) return { enum: [...c.enumValues] };
+  const mine = c.arrayDimensions ? [] : checks.filter((k) => k.column === c.name);
+  const eq = mine.find((k) => k.operator === "=");
+  if (eq) return { const: eq.kind === "string" ? eq.value : Number(eq.value) };
+  switch (c.tsType) {
+    case "string": {
+      const out = { type: "string" };
+      if (c.format === "uuid") out.format = UUID_FORMAT;
+      else if (c.format && import_validation_core2.COLUMN_FORMATS[c.format]) out.pattern = import_validation_core2.COLUMN_FORMATS[c.format];
+      if (c.maxLength !== void 0) out.maxLength = c.maxLength;
+      applyLengths(out, c, lengths);
+      return out;
+    }
+    case "number": {
+      const out = { type: (0, import_validation_core2.isIntegerColumn)(c) ? "integer" : "number" };
+      if (!c.arrayDimensions) applyNumericBounds(out, c, checks, target);
+      return out;
+    }
+    case "bigint":
+      return { type: "string", pattern: "^-?\\d+$" };
+    case "boolean":
+      return { type: "boolean" };
+    case "Date":
+      return { type: "string", format: "date-time" };
+    case "Uint8Array":
+      return { type: "string", contentEncoding: "base64" };
+    default:
+      return {};
+  }
+}
+function applyLengths(out, c, lengths) {
+  for (const k of lengths.filter((x) => x.column === c.name)) {
+    const n = Number(k.value);
+    if (k.operator === ">=") out.minLength = Math.max(Number(out.minLength ?? 0), n);
+    else if (k.operator === ">") out.minLength = Math.max(Number(out.minLength ?? 0), n + 1);
+    else if (k.operator === "<=") out.maxLength = Math.min(Number(out.maxLength ?? Infinity), n);
+    else if (k.operator === "<") out.maxLength = Math.min(Number(out.maxLength ?? Infinity), n - 1);
+    else if (k.operator === "=") {
+      out.minLength = n;
+      out.maxLength = n;
+    }
+  }
+}
+function applyNumericBounds(out, c, checks, target) {
+  let min = c.min !== void 0 ? { value: Number(c.min), exclusive: false } : void 0;
+  let max = c.max !== void 0 ? { value: Number(c.max), exclusive: false } : void 0;
+  for (const k of checks.filter((x) => x.column === c.name && x.kind === "number")) {
+    if (k.operator === ">=") min = { value: Number(k.value), exclusive: false };
+    else if (k.operator === ">") min = { value: Number(k.value), exclusive: true };
+    else if (k.operator === "<=") max = { value: Number(k.value), exclusive: false };
+    else if (k.operator === "<") max = { value: Number(k.value), exclusive: true };
+  }
+  const old = target === "openapi-3.0";
+  if (min) {
+    if (min.exclusive && !old) out.exclusiveMinimum = min.value;
+    else {
+      out.minimum = min.value;
+      if (min.exclusive) out.exclusiveMinimum = true;
+    }
+  }
+  if (max) {
+    if (max.exclusive && !old) out.exclusiveMaximum = max.value;
+    else {
+      out.maximum = max.value;
+      if (max.exclusive) out.exclusiveMaximum = true;
+    }
+  }
+}
+function cardinalityBounds(c, cardinalities) {
+  if (!c.arrayDimensions) return {};
+  const out = {};
+  for (const k of cardinalities.filter((x) => x.column === c.name)) {
+    const n = Number(k.value);
+    if (k.operator === ">=") out.minItems = n;
+    else if (k.operator === ">") out.minItems = n + 1;
+    else if (k.operator === "<=") out.maxItems = n;
+    else if (k.operator === "<") out.maxItems = n - 1;
+    else if (k.operator === "=") {
+      out.minItems = n;
+      out.maxItems = n;
+    }
+  }
+  return out;
+}
+function makeNullable(s, target) {
+  if (target === "openapi-3.0") return { ...s, nullable: true };
+  if (s.type === void 0) {
+    if (Array.isArray(s.enum)) return { ...s, enum: [...s.enum, null] };
+    if ("const" in s) {
+      const { const: k, ...rest } = s;
+      return { ...rest, enum: [k, null] };
+    }
+    return s;
+  }
+  return { ...s, type: [s.type, "null"] };
+}
+function columnSchema(c, mode, target, checks, sets, lengths, cardinalities, applyDefault) {
+  let s = baseSchema(c, mode, target, checks, sets, lengths);
+  const dims = c.arrayDimensions ?? 0;
+  for (let i = 0; i < dims; i++) {
+    s = { type: "array", items: s, ...i === dims - 1 ? cardinalityBounds(c, cardinalities) : {} };
+  }
+  if (c.nullable) s = makeNullable(s, target);
+  if (mode === "insert" && applyDefault && c.defaultValue !== void 0) {
+    s = { ...s, default: c.defaultValue };
+  }
+  return s;
+}
+function rowDescription(rows, cols) {
+  const present = new Set(cols.map((c) => c.name));
+  const applicable = rows.filter((r) => present.has(r.left) && present.has(r.right));
+  if (!applicable.length) return void 0;
+  const list = applicable.map((r) => `${r.name ? `${r.name}: ` : ""}${r.left} ${r.operator} ${r.right}`).join("; ");
+  return `Row constraints not expressible in JSON Schema: ${list}`;
+}
+function tableSchema(table, cols, mode, target, applyDefaults, parsed) {
+  const properties = {};
+  const required = [];
+  for (const c of cols) {
+    properties[c.name] = columnSchema(
+      c,
+      mode,
+      target,
+      parsed.checks,
+      parsed.sets,
+      parsed.lengths,
+      parsed.cardinalities,
+      applyDefaults
+    );
+    const suppliedOnInsert = c.hasDefault || applyDefaults && c.defaultValue !== void 0 || c.isGenerated;
+    const optional = mode === "update" || mode === "insert" && suppliedOnInsert;
+    if (!optional) required.push(c.name);
+  }
+  const desc = rowDescription(parsed.rows, cols);
+  return {
+    ...target === "draft-2020-12" ? { $schema: DRAFT } : {},
+    $id: `${table.tsName}.${mode}`,
+    title: `${mode} ${table.tsName}`,
+    ...desc ? { description: desc } : {},
+    type: "object",
+    properties,
+    ...required.length ? { required } : {},
+    additionalProperties: false
+  };
+}
+function collect(table) {
+  const parsed = (table.checks ?? []).map((k) => (0, import_validation_core2.parseCheck)(k.expression, k.name));
+  return {
+    checks: parsed.flatMap((p) => p.ok ? p.checks : []),
+    sets: parsed.flatMap((p) => p.ok ? p.sets ?? [] : []),
+    rows: parsed.flatMap((p) => p.ok ? p.rows ?? [] : []),
+    lengths: parsed.flatMap((p) => p.ok ? p.lengths ?? [] : []),
+    cardinalities: parsed.flatMap((p) => p.ok ? p.cardinalities ?? [] : [])
+  };
+}
+function tableSchemas(table, opts = {}) {
+  const target = opts.target ?? "draft-2020-12";
+  const parsed = collect(table);
+  const build = (cols, mode) => tableSchema(table, cols, mode, target, !!opts.applyDefaults, parsed);
+  return {
+    insert: build((0, import_validation_core2.insertColumns)(table), "insert"),
+    update: build((0, import_validation_core2.updateColumns)(table), "update"),
+    select: build((0, import_validation_core2.selectColumns)(table), "select")
+  };
+}
+function componentsDocument(tables, opts = {}) {
+  const schemas = {};
+  for (const table of tables) {
+    const built = tableSchemas(table, opts);
+    for (const mode of ["insert", "update", "select"]) {
+      const name = `${table.tsName}${mode[0].toUpperCase()}${mode.slice(1)}`;
+      const { $schema: _dialect, $id: _id, ...rest } = built[mode];
+      schemas[name] = rest;
+    }
+  }
+  return { schemas };
+}
+function renderTableModule(table, affix, target, applyDefaults) {
+  const T = table.tsName;
+  const schemas = tableSchemas(table, { target, applyDefaults });
+  const decl = (mode) => `export const ${(0, import_validation_core2.schemaName)(mode, T, affix)} = ${JSON.stringify(schemas[mode], null, 2)} as const;
+
+export type ${(0, import_validation_core2.typeName)(mode, T, affix)} = typeof ${(0, import_validation_core2.schemaName)(mode, T, affix)};`;
+  return [decl("insert"), decl("update"), decl("select")].join("\n\n") + "\n";
+}
+function buildHeader(h) {
+  if (h?.enabled === false) return "";
+  const text = h?.text ?? "// Generated by DRZL. Do not edit by hand.";
+  return `${text}
+
+`;
+}
+var import_validation_core2, DEFAULT_FILE_SUFFIX, DRAFT, UUID_FORMAT, JsonSchemaGenerator, index_default;
+var init_dist = __esm({
+  "../generator-json-schema/dist/index.js"() {
+    "use strict";
+    import_validation_core2 = require("@drzl/validation-core");
+    DEFAULT_FILE_SUFFIX = ".schema.ts";
+    DRAFT = "https://json-schema.org/draft/2020-12/schema";
+    UUID_FORMAT = "uuid";
+    JsonSchemaGenerator = class {
+      constructor(analysis) {
+        this.analysis = analysis;
+        this.library = "json-schema";
+      }
+      async generate(opts) {
+        const fs3 = await import("fs/promises");
+        const path5 = await import("path");
+        const out = path5.resolve(process.cwd(), opts.outDir);
+        const files = [];
+        await fs3.mkdir(out, { recursive: true });
+        const affix = (0, import_validation_core2.resolveAffix)(opts);
+        const fileSuffix = opts.fileSuffix ?? DEFAULT_FILE_SUFFIX;
+        const target = opts.target ?? "draft-2020-12";
+        for (const table of this.analysis.tables) {
+          const filePath = path5.join(out, (0, import_validation_core2.moduleFileName)(table.tsName, fileSuffix));
+          const code = renderTableModule(table, affix, target, !!opts.applyDefaults);
+          const formatted = await (0, import_validation_core2.formatCode)(
+            buildHeader(opts.outputHeader) + code,
+            filePath,
+            opts.format
+          );
+          await fs3.writeFile(filePath, formatted, "utf8");
+          files.push(filePath);
+        }
+        if (opts.components) {
+          const doc = componentsDocument(this.analysis.tables, {
+            target,
+            applyDefaults: !!opts.applyDefaults
+          });
+          const componentsPath = path5.join(out, "components.ts");
+          const code = `export const components = ${JSON.stringify(doc, null, 2)} as const;
+`;
+          await fs3.writeFile(
+            componentsPath,
+            await (0, import_validation_core2.formatCode)(buildHeader(opts.outputHeader) + code, componentsPath, opts.format),
+            "utf8"
+          );
+          files.push(componentsPath);
+        }
+        const indexPath = path5.join(out, "index.ts");
+        const index = this.analysis.tables.map((t) => `export * from '${(0, import_validation_core2.moduleSpecifier)(t.tsName, fileSuffix, opts.importExtension)}';`).concat(
+          opts.components ? [`export * from './components${opts.importExtension === "none" ? "" : ".js"}';`] : []
+        ).join("\n") + "\n";
+        const indexFormatted = await (0, import_validation_core2.formatCode)(
+          buildHeader(opts.outputHeader) + index,
+          indexPath,
+          opts.format
+        );
+        await fs3.writeFile(indexPath, indexFormatted, "utf8");
+        files.push(indexPath);
+        return files;
+      }
+      renderTable(table, opts) {
+        return renderTableModule(
+          table,
+          (0, import_validation_core2.resolveAffix)(opts),
+          opts?.target ?? "draft-2020-12",
+          !!opts?.applyDefaults
+        );
+      }
+    };
+    index_default = JsonSchemaGenerator;
+  }
+});
+
 // src/cli.ts
 var import_analyzer = require("@drzl/analyzer");
 var import_generator_orpc = require("@drzl/generator-orpc");
@@ -45,6 +359,7 @@ function validationOptions(g, cfg, outDir, caps = {}) {
     affix: g.affix,
     coerceDates: g.coerceDates,
     applyDefaults: g.applyDefaults,
+    duplicateFinder: g.duplicateFinder,
     // Only where the generator can act on them, so an unsupported option is absent rather than
     // present and ignored.
     ...caps.schemaTypes ? {
@@ -123,6 +438,14 @@ var GeneratorSchema = import_zod.z.object({
   typedColumns: import_zod.z.boolean().optional(),
   // Reproduce literal column defaults in the insert schema, so parsing fills them in.
   applyDefaults: import_zod.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: import_zod.z.boolean().optional(),
   naming: NamingSchema.optional(),
   outputHeader: import_zod.z.object({
     enabled: import_zod.z.boolean().default(true).optional(),
@@ -143,6 +466,8 @@ var GeneratorSchema = import_zod.z.object({
    * validates and then accepts the values the constraints exist to reject.
    */
   target: import_zod.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: import_zod.z.boolean().optional(),
   // service generator specific options
   path: import_zod.z.string().optional(),
   dataAccess: import_zod.z.enum(["stub", "drizzle"]).default("stub").optional(),
@@ -695,13 +1020,14 @@ program.command("generate").description("Run configured generators (drzl.config.
         }
       } else if (g.kind === "json-schema") {
         try {
-          const { JsonSchemaGenerator } = await import("@drzl/generator-json-schema");
-          const gen = new JsonSchemaGenerator(analysis);
+          const { JsonSchemaGenerator: JsonSchemaGenerator2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
+          const gen = new JsonSchemaGenerator2(analysis);
           const target = g.path ?? "src/validators/json-schema";
           const files = await gen.generate({
             // JSON Schema is data, so nothing here references a type from the schema module.
             ...validationOptions(g, cfg, target, { schemaTypes: false }),
-            target: g.target
+            target: g.target,
+            components: g.components
           });
           progress.stop();
           (0, import_ora.default)().succeed(import_chalk2.default.green(`Generated (json-schema): ${files.length} files`));
@@ -710,7 +1036,11 @@ program.command("generate").description("Run configured generators (drzl.config.
           progress.stop();
           console.error(
             import_chalk2.default.red("JSON Schema generator missing."),
-            import_chalk2.default.yellow("\nInstall with: npm install @drzl/generator-json-schema")
+            import_chalk2.default.yellow("\nInstall with: npm install @drzl/generator-json-schema"),
+            // An optional dependency, unlike the other generators, until its npm trusted
+            // publisher exists. A missing optional dependency is skipped rather than failing
+            // the install, which is what keeps `npm i @drzl/cli` working meanwhile.
+            ""
           );
           console.error(import_chalk2.default.gray("Error details:"), e?.message ?? e);
           process.exit(1);