@drzl/cli 4.16.0 → 4.18.0

package/dist/cli.cjs

@@ -261,7 +261,7 @@ ${entries}
   const decided = [...declared, body].join("\n\n");
   const imports = [];
   if (useShared) {
-    const sharedAffix = (0, import_validation_core2.resolveAffix)({
+    const sharedAffix = (0, import_validation_core3.resolveAffix)({
       affix: opts.validation?.affix,
       schemaSuffix: opts.validation?.schemaSuffix
     });
@@ -271,21 +271,21 @@ ${entries}
       ["select", selectName]
     ].filter(([, local]) => decided.includes(local));
     if (wanted.length) {
-      const spec = (0, import_validation_core2.resolveConfiguredImport)(
+      const spec = (0, import_validation_core3.resolveConfiguredImport)(
         opts.validation.importPath,
         ctx.out,
         process.cwd(),
         opts.importExtension
       );
       const names = wanted.map(([mode, local]) => {
-        const exported = (0, import_validation_core2.schemaName)(mode, table.tsName, sharedAffix);
+        const exported = (0, import_validation_core3.schemaName)(mode, table.tsName, sharedAffix);
         return exported === local ? local : `${exported} as ${local}`;
       }).join(", ");
       imports.push(`import { ${names} } from '${spec}';`);
     }
   }
   imports.push(
-    `import { ${[builder, "router"].sort().join(", ")} } from '${(0, import_validation_core2.importSpecifier)(
+    `import { ${[builder, "router"].sort().join(", ")} } from '${(0, import_validation_core3.importSpecifier)(
       `./${BASE_MODULE}.ts`,
       opts.importExtension
     )}';`
@@ -334,7 +334,7 @@ function relationProcedures(table, lib, selectSchemaName, taken, service) {
   return out;
 }
 function renderBarrel(routers, ctx, path6, opts) {
-  const baseSpec = (0, import_validation_core2.importSpecifier)(`./${BASE_MODULE}.ts`, opts.importExtension);
+  const baseSpec = (0, import_validation_core3.importSpecifier)(`./${BASE_MODULE}.ts`, opts.importExtension);
   const reExports = `export { createCallerFactory, publicProcedure, router } from '${baseSpec}';
 ` + (opts.databaseInjection?.enabled === true ? `export { dbProcedure } from '${baseSpec}';
 ` : "") + `export type { Context } from '${baseSpec}';
@@ -352,7 +352,7 @@ export type AppRouter = typeof appRouter;
 ${reExports}`;
   }
   const entries = routers.map(({ filePath, exportName, table }) => ({
-    rel: (0, import_validation_core2.importSpecifier)(
+    rel: (0, import_validation_core3.importSpecifier)(
       "./" + path6.relative(ctx.out, filePath).replace(/\\/g, "/"),
       opts.importExtension
     ),
@@ -393,7 +393,7 @@ function routerExportName(table, naming) {
 function serviceImportSpecifier(table, ctx, opts) {
   const rel = relativePosix(ctx.out, ctx.services);
   const dir = !rel ? "." : rel.startsWith(".") ? rel : `./${rel}`;
-  return (0, import_validation_core2.importSpecifier)(`${dir}/${singularize(table.tsName)}Service.ts`, opts.importExtension);
+  return (0, import_validation_core3.importSpecifier)(`${dir}/${singularize(table.tsName)}Service.ts`, opts.importExtension);
 }
 function relativePosix(from, to) {
   const norm = (p) => p.replace(/\\/g, "/").replace(/\/+$/, "");
@@ -413,11 +413,11 @@ function buildHeader(h) {
   ];
   return lines.join("\n") + "\n\n";
 }
-var import_validation_core2, TRPC_MAJOR, q, LIB_IMPORTS, LIB_USAGE, LIBS, cap, singularize, isIdent, BASE_MODULE, TRPCGenerator, index_default;
+var import_validation_core3, TRPC_MAJOR, q, LIB_IMPORTS, LIB_USAGE, LIBS, cap, singularize, isIdent, BASE_MODULE, TRPCGenerator, index_default;
 var init_dist = __esm({
   "../generator-trpc/dist/index.js"() {
     "use strict";
-    import_validation_core2 = require("@drzl/validation-core");
+    import_validation_core3 = require("@drzl/validation-core");
     TRPC_MAJOR = 11;
     q = (v) => JSON.stringify(v);
     LIB_IMPORTS = {
@@ -510,7 +510,7 @@ ${body}
         await fs3.mkdir(out, { recursive: true });
         const files = [];
         const write = async (filePath, content) => {
-          const formatted = await (0, import_validation_core2.formatCode)(
+          const formatted = await (0, import_validation_core3.formatCode)(
             buildHeader(opts.outputHeader) + content,
             filePath,
             opts.format
@@ -547,9 +547,11 @@ ${body}
 // ../generator-json-schema/dist/index.js
 var dist_exports2 = {};
 __export(dist_exports2, {
+  DRAFT: () => DRAFT,
   JsonSchemaGenerator: () => JsonSchemaGenerator,
   componentsDocument: () => componentsDocument,
   default: () => index_default2,
+  openApiDocument: () => openApiDocument,
   tableSchemas: () => tableSchemas
 });
 function baseSchema(c, mode, target, checks, sets, lengths) {
@@ -561,7 +563,7 @@ function baseSchema(c, mode, target, checks, sets, lengths) {
       case "custom":
         return {};
       case "buffer":
-        return { type: "string", contentEncoding: "base64" };
+        return base64(target);
       case "tuple":
         return target === "openapi-3.0" ? { type: "array", items: { type: "number" }, minItems: s.length, maxItems: s.length } : {
           type: "array",
@@ -596,19 +598,22 @@ function baseSchema(c, mode, target, checks, sets, lengths) {
   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) };
+  if (eq) {
+    const only = eq.kind === "string" ? eq.value : Number(eq.value);
+    return target === "openapi-3.0" ? { enum: [only] } : { const: only };
+  }
   switch (c.tsType) {
     case "string": {
       const out = { type: "string" };
       if (c.format === "uuid") out.format = UUID_FORMAT;
-      else if (c.format && import_validation_core3.COLUMN_FORMATS[c.format]) out.pattern = import_validation_core3.COLUMN_FORMATS[c.format];
+      else if (c.format && import_validation_core5.COLUMN_FORMATS[c.format]) out.pattern = import_validation_core5.COLUMN_FORMATS[c.format];
       if (c.maxLength !== void 0) out.maxLength = c.maxLength;
       applyByteCap(out, c);
       applyLengths(out, c, lengths);
       return out;
     }
     case "number": {
-      const out = { type: (0, import_validation_core3.isIntegerColumn)(c) ? "integer" : "number" };
+      const out = { type: (0, import_validation_core5.isIntegerColumn)(c) ? "integer" : "number" };
       if (!c.arrayDimensions) applyNumericBounds(out, c, checks, target);
       return out;
     }
@@ -619,7 +624,7 @@ function baseSchema(c, mode, target, checks, sets, lengths) {
     case "Date":
       return { type: "string", format: "date-time" };
     case "Uint8Array":
-      return { type: "string", contentEncoding: "base64" };
+      return base64(target);
     default:
       return {};
   }
@@ -745,7 +750,7 @@ function tableSchema(table, cols, mode, target, applyDefaults, parsed) {
   };
 }
 function collect(table) {
-  const parsed = (table.checks ?? []).map((k) => (0, import_validation_core3.parseCheck)(k.expression, k.name));
+  const parsed = (table.checks ?? []).map((k) => (0, import_validation_core5.parseCheck)(k.expression, k.name));
   return {
     checks: parsed.flatMap((p) => p.ok ? p.checks : []),
     sets: parsed.flatMap((p) => p.ok ? p.sets ?? [] : []),
@@ -757,11 +762,11 @@ function collect(table) {
 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);
+  const build2 = (cols, mode) => tableSchema(table, cols, mode, target, !!opts.applyDefaults, parsed);
   return {
-    insert: build((0, import_validation_core3.insertColumns)(table), "insert"),
-    update: build((0, import_validation_core3.updateColumns)(table), "update"),
-    select: build((0, import_validation_core3.selectColumns)(table), "select")
+    insert: build2((0, import_validation_core5.insertColumns)(table), "insert"),
+    update: build2((0, import_validation_core5.updateColumns)(table), "update"),
+    select: build2((0, import_validation_core5.selectColumns)(table), "select")
   };
 }
 function componentsDocument(tables, opts = {}) {
@@ -776,14 +781,231 @@ function componentsDocument(tables, opts = {}) {
   }
   return { schemas };
 }
+function keyColumns2(table) {
+  const names = table.primaryKey?.columns ?? [];
+  if (!names.length) return null;
+  const cols = names.map((n) => table.columns.find((c) => c.name === n));
+  if (cols.some((c) => !c)) return null;
+  return cols;
+}
+function foreignKeysOf(table) {
+  if (table.foreignKeys?.length) return table.foreignKeys;
+  return table.columns.filter((c) => c.references).map((c) => ({
+    columns: [c.name],
+    foreignTable: c.references.table,
+    foreignColumns: [c.references.column]
+  }));
+}
+function build(tables, opts) {
+  const target = opts.target ?? "draft-2020-12";
+  const schemaTarget = target === "openapi-3.0" ? "openapi-3.0" : "openapi-3.1";
+  const failure = String(opts.validationStatus ?? 400);
+  const paths = {};
+  const schemas = {};
+  const tags = [];
+  const operationIds = /* @__PURE__ */ new Map();
+  const owner = /* @__PURE__ */ new Map();
+  const claim = (path6, by, label) => {
+    const taken = owner.get(path6);
+    if (taken !== void 0 && taken.by !== by) {
+      throw new Error(
+        `@drzl/generator-json-schema: the OpenAPI path "${path6}" is claimed twice: by table "${taken.label}" (exported as ${taken.by}) and by table "${label}" (exported as ${by}). A path names one resource, so one of the two has to be left out of this generator with the config's "exclude" list.`
+      );
+    }
+    owner.set(path6, { by, label });
+  };
+  const operation = (id, table, rest) => {
+    const clash = operationIds.get(id);
+    if (clash !== void 0) {
+      throw new Error(
+        `@drzl/generator-json-schema: the operationId "${id}" would be emitted for both "${clash}" and "${table.name}". An operationId is the method name a client generator derives, and the specification requires it to be unique across the document.`
+      );
+    }
+    operationIds.set(id, table.name);
+    return { operationId: id, tags: [table.name], ...rest };
+  };
+  const built = tables.map((table) => ({
+    table,
+    key: keyColumns2(table),
+    segment: resourceSegment(table),
+    schemas: tableSchemas(table, { target: schemaTarget, applyDefaults: opts.applyDefaults })
+  }));
+  for (const { table, key, segment, schemas: built3 } of built) {
+    for (const mode of modesFor(table, key)) {
+      const { $schema: _dialect, $id: _id, ...rest } = built3[mode];
+      schemas[componentName(table, mode)] = rest;
+    }
+    const notes = [];
+    if (!key) notes.push("It has no primary key, so no path addresses a single row.");
+    if (table.readOnly) {
+      notes.push("It refuses every write, so only reads are described.");
+    }
+    tags.push({ name: table.name, description: [`Table "${table.name}".`, ...notes].join(" ") });
+    const T = pascal(table.tsName);
+    const select = ref(componentName(table, "select"));
+    const validationFailed = {
+      description: "The request does not match the schema for this operation.",
+      ...jsonBody(ref(ERROR_SCHEMA))
+    };
+    const collidable = [
+      ...table.primaryKey ? [`primary key (${table.primaryKey.columns.join(", ")})`] : [],
+      ...table.unique.map((u) => `${u.name ? `${u.name} ` : ""}(${u.columns.join(", ")})`)
+    ];
+    const conflict = (constraints) => ({
+      description: `The row collides with an existing one on ${constraints.join("; ")}.`,
+      ...jsonBody(ref(ERROR_SCHEMA))
+    });
+    const collection = `/${segment}`;
+    claim(collection, table.tsName, table.name);
+    const item = {
+      get: operation(`list${T}`, table, {
+        summary: `List every ${table.name} row.`,
+        // No pagination parameters. Whether the server implements a limit, an offset or a cursor is
+        // not something a Drizzle schema states, and a declared parameter nothing honours is worse
+        // than an undeclared one.
+        responses: {
+          "200": {
+            description: `Every ${table.name} row.`,
+            ...jsonBody({ type: "array", items: select })
+          }
+        }
+      })
+    };
+    if (!table.readOnly) {
+      item.post = operation(`create${T}`, table, {
+        summary: `Create a ${table.name} row.`,
+        requestBody: { required: true, ...jsonBody(ref(componentName(table, "insert"))) },
+        responses: {
+          "201": { description: `The ${table.name} row that was created.`, ...jsonBody(select) },
+          [failure]: validationFailed,
+          ...collidable.length ? { "409": conflict(collidable) } : {}
+        }
+      });
+    }
+    paths[collection] = item;
+    if (!key) continue;
+    const itemPath = `${collection}/${key.map((c) => `{${c.name}}`).join("/")}`;
+    claim(itemPath, table.tsName, table.name);
+    const parameters = key.map((c) => ({
+      name: c.name,
+      in: "path",
+      required: true,
+      description: `${c.name}, from the primary key of ${table.name}.`,
+      // The column's own schema rather than a string, so an integer key is declared as one and a
+      // uuid key carries its format. This is the whole point of reading the real key.
+      schema: built3.select.properties[c.name] ?? {}
+    }));
+    const missing = {
+      description: `No ${table.name} row has that ${key.map((c) => c.name).join(" and ")}.`,
+      ...jsonBody(ref(ERROR_SCHEMA))
+    };
+    const byId = {
+      parameters,
+      get: operation(`get${T}`, table, {
+        summary: `Read one ${table.name} row.`,
+        responses: {
+          "200": { description: `The requested ${table.name} row.`, ...jsonBody(select) },
+          [failure]: validationFailed,
+          "404": missing
+        }
+      })
+    };
+    if (!table.readOnly) {
+      byId.patch = operation(`update${T}`, table, {
+        summary: `Patch one ${table.name} row.`,
+        requestBody: { required: true, ...jsonBody(ref(componentName(table, "update"))) },
+        responses: {
+          "200": { description: `The ${table.name} row after the patch.`, ...jsonBody(select) },
+          [failure]: validationFailed,
+          "404": missing,
+          // The primary key is not in the update schema, so a patch cannot collide on it. Only a
+          // unique constraint over other columns can.
+          ...table.unique.length ? {
+            "409": conflict(
+              table.unique.map((u) => `${u.name ? `${u.name} ` : ""}(${u.columns.join(", ")})`)
+            )
+          } : {}
+        }
+      });
+      byId.delete = operation(`delete${T}`, table, {
+        summary: `Delete one ${table.name} row.`,
+        responses: {
+          // No body. Handing back the deleted row is the alternative and it is not a true statement
+          // on every dialect DRZL supports: RETURNING is Postgres and SQLite, and MySQL has no such
+          // clause, so an implementation there has nothing to send.
+          "204": { description: `The ${table.name} row was deleted. No content is returned.` },
+          [failure]: validationFailed,
+          "404": missing
+        }
+      });
+    }
+    paths[itemPath] = byId;
+    if (!opts.includeRelations) continue;
+    for (const child of built) {
+      if (child.table === table) continue;
+      const matching = foreignKeysOf(child.table).filter(
+        (fk) => fk.foreignTable === table.name && fk.foreignColumns.length === key.length && fk.foreignColumns.every((c, i) => c === key[i].name)
+      );
+      if (matching.length !== 1) continue;
+      const subPath = `${itemPath}/${child.segment}`;
+      claim(
+        subPath,
+        `${table.tsName} -> ${child.table.tsName}`,
+        `${table.name} -> ${child.table.name}`
+      );
+      paths[subPath] = {
+        parameters,
+        get: operation(`list${T}${pascal(child.table.tsName)}`, child.table, {
+          summary: `List the ${child.table.name} rows belonging to one ${table.name} row.`,
+          responses: {
+            "200": {
+              description: `The ${child.table.name} rows whose ${matching[0].columns.join(", ")} names this ${table.name} row.`,
+              ...jsonBody({ type: "array", items: ref(componentName(child.table, "select")) })
+            },
+            [failure]: validationFailed,
+            "404": missing
+          }
+        })
+      };
+    }
+  }
+  return { paths, schemas, tags };
+}
+function openApiDocument(tables, opts = {}) {
+  const target = opts.target ?? "draft-2020-12";
+  const { paths, schemas, tags } = build(tables, opts);
+  if (ERROR_SCHEMA in schemas) {
+    throw new Error(
+      `@drzl/generator-json-schema: a table produced the component schema name "${ERROR_SCHEMA}", which the document already uses for its error responses.`
+    );
+  }
+  return {
+    openapi: target === "openapi-3.0" ? "3.0.3" : "3.1.1",
+    info: {
+      title: opts.info?.title ?? "API",
+      version: opts.info?.version ?? "0.0.0",
+      description: opts.info?.description ?? "Generated by DRZL from a Drizzle schema. Paths, request bodies and response bodies are derived from the schema alone; nothing here has been checked against a running server."
+    },
+    ...opts.servers?.length ? { servers: opts.servers } : {},
+    paths,
+    components: { schemas: { ...schemas, [ERROR_SCHEMA]: errorSchema() } },
+    tags
+  };
+}
 function renderTableModule(table, affix, target, applyDefaults) {
   const T = table.tsName;
   const schemas = tableSchemas(table, { target, applyDefaults });
-  const decl = (mode) => `export const ${(0, import_validation_core3.schemaName)(mode, T, affix)} = ${JSON.stringify(schemas[mode], null, 2)} as const;
+  const decl = (mode) => `export const ${(0, import_validation_core4.schemaName)(mode, T, affix)} = ${JSON.stringify(schemas[mode], null, 2)} as const;
 
-export type ${(0, import_validation_core3.typeName)(mode, T, affix)} = typeof ${(0, import_validation_core3.schemaName)(mode, T, affix)};`;
+export type ${(0, import_validation_core4.typeName)(mode, T, affix)} = typeof ${(0, import_validation_core4.schemaName)(mode, T, affix)};`;
   return [decl("insert"), decl("update"), decl("select")].join("\n\n") + "\n";
 }
+function resolveDocument(opt) {
+  if (!opt) return null;
+  const o = opt === true ? {} : opt;
+  if (o.enabled === false) return null;
+  return { ...o, format: o.format ?? "ts" };
+}
 function buildHeader2(h) {
   if (h?.enabled === false) return "";
   const text = h?.text ?? "// Generated by DRZL. Do not edit by hand.";
@@ -791,14 +1013,38 @@ function buildHeader2(h) {
 
 `;
 }
-var import_validation_core3, DEFAULT_FILE_SUFFIX, DRAFT, UUID_FORMAT, JsonSchemaGenerator, index_default2;
+var import_validation_core4, import_validation_core5, DRAFT, UUID_FORMAT, base64, ERROR_SCHEMA, componentName, ref, pascal, modesFor, resourceSegment, jsonBody, errorSchema, DEFAULT_FILE_SUFFIX, JsonSchemaGenerator, index_default2;
 var init_dist2 = __esm({
   "../generator-json-schema/dist/index.js"() {
     "use strict";
-    import_validation_core3 = require("@drzl/validation-core");
-    DEFAULT_FILE_SUFFIX = ".schema.ts";
+    import_validation_core4 = require("@drzl/validation-core");
+    import_validation_core5 = require("@drzl/validation-core");
     DRAFT = "https://json-schema.org/draft/2020-12/schema";
     UUID_FORMAT = "uuid";
+    base64 = (target) => target === "openapi-3.0" ? { type: "string", format: "byte" } : { type: "string", contentEncoding: "base64" };
+    ERROR_SCHEMA = "Error";
+    componentName = (table, mode) => `${table.tsName}${mode[0].toUpperCase()}${mode.slice(1)}`;
+    ref = (name) => ({ $ref: `#/components/schemas/${name}` });
+    pascal = (s) => s.charAt(0).toUpperCase() + s.slice(1);
+    modesFor = (table, key) => [
+      ...table.readOnly ? [] : ["insert"],
+      ...table.readOnly || !key ? [] : ["update"],
+      "select"
+    ];
+    resourceSegment = (table) => encodeURIComponent(table.name);
+    jsonBody = (schema) => ({ content: { "application/json": { schema } } });
+    errorSchema = () => ({
+      title: "error",
+      description: "What an operation returns when it does not return the row.",
+      type: "object",
+      properties: {
+        message: { type: "string" },
+        code: { type: "string" }
+      },
+      required: ["message"],
+      additionalProperties: true
+    });
+    DEFAULT_FILE_SUFFIX = ".schema.ts";
     JsonSchemaGenerator = class {
       constructor(analysis) {
         this.analysis = analysis;
@@ -810,13 +1056,14 @@ var init_dist2 = __esm({
         const out = path6.resolve(process.cwd(), opts.outDir);
         const files = [];
         await fs3.mkdir(out, { recursive: true });
-        const affix = (0, import_validation_core3.resolveAffix)(opts);
+        const affix = (0, import_validation_core4.resolveAffix)(opts);
         const fileSuffix = opts.fileSuffix ?? DEFAULT_FILE_SUFFIX;
         const target = opts.target ?? "draft-2020-12";
+        const document = resolveDocument(opts.document);
         for (const table of this.analysis.tables) {
-          const filePath = path6.join(out, (0, import_validation_core3.moduleFileName)(table.tsName, fileSuffix));
+          const filePath = path6.join(out, (0, import_validation_core4.moduleFileName)(table.tsName, fileSuffix));
           const code = renderTableModule(table, affix, target, !!opts.applyDefaults);
-          const formatted = await (0, import_validation_core3.formatCode)(
+          const formatted = await (0, import_validation_core4.formatCode)(
             buildHeader2(opts.outputHeader) + code,
             filePath,
             opts.format
@@ -834,16 +1081,44 @@ var init_dist2 = __esm({
 `;
           await fs3.writeFile(
             componentsPath,
-            await (0, import_validation_core3.formatCode)(buildHeader2(opts.outputHeader) + code, componentsPath, opts.format),
+            await (0, import_validation_core4.formatCode)(buildHeader2(opts.outputHeader) + code, componentsPath, opts.format),
             "utf8"
           );
           files.push(componentsPath);
         }
+        if (document) {
+          const built = openApiDocument(this.analysis.tables, {
+            target,
+            applyDefaults: !!opts.applyDefaults,
+            includeRelations: !!opts.includeRelations,
+            info: document.info,
+            servers: document.servers,
+            validationStatus: document.validationStatus
+          });
+          const body = JSON.stringify(built, null, 2);
+          if (document.format !== "json") {
+            const tsPath = path6.join(out, "openapi.ts");
+            const code = `export const openapi = ${body} as const;
+`;
+            await fs3.writeFile(
+              tsPath,
+              await (0, import_validation_core4.formatCode)(buildHeader2(opts.outputHeader) + code, tsPath, opts.format),
+              "utf8"
+            );
+            files.push(tsPath);
+          }
+          if (document.format !== "ts") {
+            const jsonPath = path6.join(out, "openapi.json");
+            await fs3.writeFile(jsonPath, body + "\n", "utf8");
+            files.push(jsonPath);
+          }
+        }
+        const ext = opts.importExtension === "none" ? "" : ".js";
         const indexPath = path6.join(out, "index.ts");
-        const index = this.analysis.tables.map((t) => `export * from '${(0, import_validation_core3.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_core3.formatCode)(
+        const index = this.analysis.tables.map(
+          (t) => `export * from '${(0, import_validation_core4.moduleSpecifier)(t.tsName, fileSuffix, opts.importExtension)}';`
+        ).concat(opts.components ? [`export * from './components${ext}';`] : []).concat(document && document.format !== "json" ? [`export * from './openapi${ext}';`] : []).join("\n") + "\n";
+        const indexFormatted = await (0, import_validation_core4.formatCode)(
           buildHeader2(opts.outputHeader) + index,
           indexPath,
           opts.format
@@ -855,7 +1130,7 @@ var init_dist2 = __esm({
       renderTable(table, opts) {
         return renderTableModule(
           table,
-          (0, import_validation_core3.resolveAffix)(opts),
+          (0, import_validation_core4.resolveAffix)(opts),
           opts?.target ?? "draft-2020-12",
           !!opts?.applyDefaults
         );
@@ -868,13 +1143,53 @@ var init_dist2 = __esm({
 // src/cli.ts
 var import_analyzer = require("@drzl/analyzer");
 var import_generator_orpc = require("@drzl/generator-orpc");
-var import_chalk2 = __toESM(require("chalk"), 1);
+var import_chalk3 = __toESM(require("chalk"), 1);
 var import_chokidar = __toESM(require("chokidar"), 1);
 var import_cli_progress = __toESM(require("cli-progress"), 1);
 var import_commander = require("commander");
 var path5 = __toESM(require("path"), 1);
 var import_ora = __toESM(require("ora"), 1);
 
+// src/validation-options.ts
+function validationOptions(g, cfg, outDir, caps = {}) {
+  return {
+    outDir,
+    outputHeader: g.outputHeader,
+    format: g.format,
+    schemaSuffix: g.schemaSuffix,
+    fileSuffix: g.fileSuffix,
+    importExtension: g.importExtension,
+    affix: g.affix,
+    coerceDates: g.coerceDates,
+    applyDefaults: g.applyDefaults,
+    duplicateFinder: g.duplicateFinder,
+    nestedSchemas: g.nestedSchemas,
+    nestedDepth: g.nestedDepth,
+    // Only where the generator can act on them, so an unsupported option is absent rather than
+    // present and ignored.
+    ...caps.schemaTypes ? {
+      // Needed by both: the reference is resolved relative to the emitted file.
+      schemaPath: cfg.schema,
+      typedJson: g.typedJson,
+      typedColumns: g.typedColumns
+    } : {}
+  };
+}
+
+// src/json-schema-options.ts
+function jsonSchemaOptions(g, cfg, outDir) {
+  return {
+    // JSON Schema is data, so nothing it emits references a type from the schema module.
+    ...validationOptions(g, cfg, outDir, { schemaTypes: false }),
+    target: g.target,
+    components: g.components,
+    document: g.document,
+    // Read only while emitting a document, where it adds `/users/{id}/posts`. The per-table
+    // schemas are flat whatever it says.
+    includeRelations: g.includeRelations
+  };
+}
+
 // src/config.ts
 var import_validation_core = require("@drzl/validation-core");
 var fs = __toESM(require("fs"), 1);
@@ -988,6 +1303,35 @@ var GeneratorSchema = import_zod.z.object({
   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(),
+  /**
+   * Also emit the whole OpenAPI document for the `json-schema` generator: paths, verbs, request and
+   * response bodies per table, with `components.schemas` embedded so the file stands alone.
+   *
+   * `true` is the short form. The object form carries the three things a Drizzle schema genuinely
+   * cannot say: what the API is called, where it is served, and which status code that particular
+   * server answers a request that fails its schema with.
+   */
+  document: import_zod.z.union([
+    import_zod.z.boolean(),
+    import_zod.z.object({
+      enabled: import_zod.z.boolean().optional(),
+      /** `ts` (default) writes a module, `json` the file OpenAPI tooling reads directly. */
+      format: import_zod.z.enum(["ts", "json", "both"]).optional(),
+      info: import_zod.z.object({
+        title: import_zod.z.string().optional(),
+        version: import_zod.z.string().optional(),
+        description: import_zod.z.string().optional()
+      }).strict().optional(),
+      /**
+       * Omitted by default, which the specification reads as a single server at `/`: the
+       * document describes whatever is serving it. A placeholder host would be a fabrication
+       * that tooling then follows.
+       */
+      servers: import_zod.z.array(import_zod.z.object({ url: import_zod.z.string(), description: import_zod.z.string().optional() }).strict()).optional(),
+      /** 400 by default. 422 is the other defensible reading; exactly one is emitted. */
+      validationStatus: import_zod.z.union([import_zod.z.literal(400), import_zod.z.literal(422)]).optional()
+    }).strict()
+  ]).optional(),
   // service generator specific options
   path: import_zod.z.string().optional(),
   dataAccess: import_zod.z.enum(["stub", "drizzle"]).default("stub").optional(),
@@ -1291,31 +1635,263 @@ function trpcOptions(g, cfg, servicesDir) {
   };
 }
 
-// src/validation-options.ts
-function validationOptions(g, cfg, outDir, caps = {}) {
+// src/doctor.ts
+var import_validation_core2 = require("@drzl/validation-core");
+var import_chalk = __toESM(require("chalk"), 1);
+var HANDLED_CODES = /* @__PURE__ */ new Set(["DRZL_ANL_UNKNOWN_COLUMN"]);
+function splitPath(path6) {
+  if (!path6) return {};
+  const dot = path6.lastIndexOf(".");
+  if (dot <= 0) return { table: path6 };
+  return { table: path6.slice(0, dot), column: path6.slice(dot + 1) };
+}
+function namedColumns(parsed) {
+  const out = [];
+  for (const c of parsed.checks) out.push({ column: c.column, scalar: true });
+  for (const s of parsed.sets ?? []) out.push({ column: s.column, scalar: true });
+  for (const l of parsed.lengths ?? []) out.push({ column: l.column, scalar: false });
+  for (const c of parsed.cardinalities ?? []) out.push({ column: c.column, scalar: false });
+  for (const r of parsed.rows ?? []) {
+    out.push({ column: r.left, scalar: false });
+    out.push({ column: r.right, scalar: false });
+  }
+  return out;
+}
+function describeShape(c) {
+  if (c.arrayDimensions) return "an array";
+  switch (c.shape?.kind) {
+    case "json":
+      return "a JSON";
+    case "buffer":
+      return "a binary";
+    case "tuple":
+    case "numberObject":
+      return "a structured";
+    case "numberVector":
+      return "a vector";
+    case "bitstring":
+      return "a bit-string";
+    case "byteString":
+      return "a byte-string";
+    case "custom":
+      return "a customType";
+    default:
+      return "a structured";
+  }
+}
+function checkFindings(table) {
+  const out = [];
+  const byName = new Map(table.columns.map((c) => [c.name, c]));
+  for (const k of table.checks ?? []) {
+    const label = k.name ? `"${k.name}"` : "an unnamed constraint";
+    const raw = k.expression ?? "";
+    const expr = raw.trim() ? raw : "(empty)";
+    const parsed = (0, import_validation_core2.parseCheck)(raw, k.name);
+    if (!parsed.ok) {
+      out.push({
+        kind: "check-declined",
+        level: "warn",
+        table: table.tsName,
+        constraint: k.name,
+        message: `CHECK ${label} on "${table.tsName}" is not translated: ${parsed.reason}. Expression: ${expr}`,
+        hint: "Only constraints whose meaning is unambiguous are translated, because a validator enforcing a guess rejects rows the database accepts. Your database still enforces this one; nothing DRZL emits does."
+      });
+      continue;
+    }
+    const seen = /* @__PURE__ */ new Set();
+    for (const { column, scalar } of namedColumns(parsed)) {
+      if (seen.has(column)) continue;
+      seen.add(column);
+      const col = byName.get(column);
+      if (!col) {
+        out.push({
+          kind: "check-unknown-column",
+          level: "warn",
+          table: table.tsName,
+          column,
+          constraint: k.name,
+          message: `CHECK ${label} on "${table.tsName}" names "${column}", which is not a column of that table, so nothing enforces it. Expression: ${expr}`,
+          hint: "A constraint is attached to the field it names. Check the spelling, or move a constraint spanning two tables out of the schema."
+        });
+        continue;
+      }
+      if (scalar && (col.arrayDimensions || col.shape)) {
+        out.push({
+          kind: "check-not-scalar",
+          level: "warn",
+          table: table.tsName,
+          column,
+          constraint: k.name,
+          message: `CHECK ${label} on "${table.tsName}" compares ${describeShape(col)} column "${column}" against a scalar literal, which does not describe it, so it is not translated. Expression: ${expr}`,
+          hint: "On an array column only cardinality(col) is read, since it is the one comparison that is about the array rather than about an element."
+        });
+      }
+    }
+  }
+  return out;
+}
+function primaryKeyFindings(table) {
+  if (table.readOnly) return [];
+  const pk = table.primaryKey?.columns ?? [];
+  if (!pk.length) {
+    const hasId = table.columns.some((c) => c.name === "id");
+    return [
+      {
+        kind: "no-primary-key",
+        level: "warn",
+        table: table.tsName,
+        message: hasId ? `Table "${table.tsName}" declares no primary key. The service and router generators fall back to a column named "id", which this table happens to have, so they work by coincidence.` : `Table "${table.tsName}" declares no primary key. The service and router generators fall back to a column named "id", which this table does not have, so the generated service will not compile.`,
+        hint: "Declare a primary key, or leave this table out with the config table filter."
+      }
+    ];
+  }
+  if (pk.length > 1) {
+    return [
+      {
+        kind: "partial-primary-key",
+        level: "warn",
+        table: table.tsName,
+        message: `Table "${table.tsName}" has a composite primary key (${pk.join(", ")}). The service and router generators key getById, update and delete on "${pk[0]}" alone, so those operations match on part of the key.`,
+        hint: "Treat the generated service as a starting point for this table and widen the key by hand."
+      }
+    ];
+  }
+  return [];
+}
+function buildDoctorReport(analysis, schemaPath) {
+  const findings = [];
+  const errors = analysis.issues.filter((i) => i.level === "error");
+  for (const i of errors) {
+    findings.push({
+      kind: "analyzer",
+      level: "error",
+      ...splitPath(i.path),
+      message: i.message,
+      hint: i.hint
+    });
+  }
+  for (const i of analysis.issues) {
+    if (i.code !== "DRZL_ANL_UNKNOWN_COLUMN") continue;
+    findings.push({
+      kind: "unknown-column",
+      level: "warn",
+      ...splitPath(i.path),
+      message: i.message,
+      hint: i.hint
+    });
+  }
+  for (const t of analysis.tables) findings.push(...checkFindings(t));
+  for (const t of analysis.tables) findings.push(...primaryKeyFindings(t));
+  for (const i of analysis.issues) {
+    if (i.level === "error" || HANDLED_CODES.has(i.code)) continue;
+    findings.push({
+      kind: "analyzer",
+      level: "warn",
+      ...splitPath(i.path),
+      message: i.message,
+      hint: i.hint
+    });
+  }
+  const columns = analysis.tables.reduce((n, t) => n + t.columns.length, 0);
+  const checks = analysis.tables.reduce((n, t) => n + (t.checks?.length ?? 0), 0);
   return {
-    outDir,
-    outputHeader: g.outputHeader,
-    format: g.format,
-    schemaSuffix: g.schemaSuffix,
-    fileSuffix: g.fileSuffix,
-    importExtension: g.importExtension,
-    affix: g.affix,
-    coerceDates: g.coerceDates,
-    applyDefaults: g.applyDefaults,
-    duplicateFinder: g.duplicateFinder,
-    nestedSchemas: g.nestedSchemas,
-    nestedDepth: g.nestedDepth,
-    // Only where the generator can act on them, so an unsupported option is absent rather than
-    // present and ignored.
-    ...caps.schemaTypes ? {
-      // Needed by both: the reference is resolved relative to the emitted file.
-      schemaPath: cfg.schema,
-      typedJson: g.typedJson,
-      typedColumns: g.typedColumns
-    } : {}
+    schema: schemaPath,
+    dialect: analysis.dialect,
+    ok: findings.length === 0,
+    counts: { tables: analysis.tables.length, columns, checks, findings: findings.length },
+    findings
   };
 }
+var SECTIONS = [
+  {
+    kinds: ["unknown-column"],
+    title: "Columns DRZL cannot type",
+    why: "These get a validator that accepts any value."
+  },
+  {
+    kinds: ["check-declined", "check-unknown-column", "check-not-scalar"],
+    title: "CHECK constraints DRZL does not enforce",
+    why: "Your database still enforces these. Nothing DRZL generates does."
+  },
+  {
+    kinds: ["no-primary-key", "partial-primary-key"],
+    title: "Primary keys the generators cannot use",
+    why: "The generated getById, update and delete are keyed on one column."
+  },
+  {
+    kinds: ["analyzer"],
+    title: "Other findings",
+    why: "Reported by the analyzer while reading the schema."
+  }
+];
+function wrap(text, indent, first = indent, width = 96) {
+  const lines = [];
+  let line = "";
+  for (const word of text.split(/\s+/)) {
+    if (line && `${line} ${word}`.length + indent.length > width) {
+      lines.push(line);
+      line = word;
+    } else {
+      line = line ? `${line} ${word}` : word;
+    }
+  }
+  if (line) lines.push(line);
+  return lines.map((l, i) => (i === 0 ? first : indent) + l).join("\n");
+}
+function renderDoctorReport(report) {
+  const out = [];
+  const plural = (n, one) => `${n} ${one}${n === 1 ? "" : "s"}`;
+  out.push(import_chalk.default.bold(`DRZL doctor  ${report.schema}`));
+  out.push(
+    import_chalk.default.dim(
+      `${report.dialect}, ${plural(report.counts.tables, "table")}, ${plural(report.counts.columns, "column")}, ${plural(report.counts.checks, "CHECK constraint")}`
+    )
+  );
+  out.push("");
+  if (report.ok) {
+    out.push(import_chalk.default.green("Nothing to report."));
+    out.push(import_chalk.default.dim("  Every column has a type DRZL can describe."));
+    out.push(import_chalk.default.dim("  Every CHECK constraint is translated into the generated validators."));
+    out.push(import_chalk.default.dim("  Every table has a primary key the generators can use."));
+    return out.join("\n");
+  }
+  const fatal = report.findings.filter((f) => f.level === "error");
+  if (fatal.length) {
+    out.push(import_chalk.default.red("DRZL could not read this schema"));
+    out.push(import_chalk.default.dim("  Nothing else could be checked."));
+    out.push("");
+    for (const f of fatal) {
+      out.push(wrap(f.message, "    ", `  ${import_chalk.default.dim("-")} `));
+      if (f.hint) out.push(import_chalk.default.dim(wrap(f.hint, "    ")));
+    }
+    out.push("");
+  }
+  for (const section of SECTIONS) {
+    const mine = report.findings.filter(
+      (f) => f.level !== "error" && section.kinds.includes(f.kind)
+    );
+    if (!mine.length) continue;
+    out.push(import_chalk.default.yellow(`${section.title}  (${mine.length})`));
+    out.push(import_chalk.default.dim(`  ${section.why}`));
+    out.push("");
+    const groups = /* @__PURE__ */ new Map();
+    for (const f of mine) {
+      const key = f.hint ?? "";
+      groups.set(key, [...groups.get(key) ?? [], f]);
+    }
+    for (const [hint, items] of groups) {
+      for (const f of items) out.push(wrap(f.message, "    ", `  ${import_chalk.default.dim("-")} `));
+      if (hint) out.push(import_chalk.default.dim(wrap(hint, "    ")));
+      out.push("");
+    }
+  }
+  out.push(
+    import_chalk.default.bold(`${plural(report.counts.findings, "finding")} in ${report.schema}.`) + import_chalk.default.dim(
+      fatal.length ? " Fix the error above and run this again." : " None of these stop DRZL generating; they are what it will not check for you."
+    )
+  );
+  return out.join("\n");
+}
 
 // src/drift.ts
 var import_node_fs = require("fs");
@@ -1393,7 +1969,7 @@ async function loadGenerator(specifier, load) {
 }
 
 // src/sponsor.ts
-var import_chalk = __toESM(require("chalk"), 1);
+var import_chalk2 = __toESM(require("chalk"), 1);
 var import_node_fs2 = require("fs");
 var import_node_path2 = __toESM(require("path"), 1);
 var CACHE_DIR = import_node_path2.default.join(process.cwd(), "node_modules", ".cache", "@drzl");
@@ -1407,9 +1983,9 @@ var tips = [
   "Need JSON Schema or OpenAPI? The json-schema generator emits both, with no runtime dependency.",
   "Use output headers to track generated files and trim noisy diffs."
 ];
-var green = (msg) => import_chalk.default.hex("#6ee7b7")(msg);
-var cyan = (msg) => import_chalk.default.cyan(msg);
-var gray = (msg) => import_chalk.default.gray(msg);
+var green = (msg) => import_chalk2.default.hex("#6ee7b7")(msg);
+var cyan = (msg) => import_chalk2.default.cyan(msg);
+var gray = (msg) => import_chalk2.default.gray(msg);
 function maybeShowSponsorMessage({
   reason = "generate",
   minIntervalMs = DEFAULT_INTERVAL_MS,
@@ -1498,13 +2074,13 @@ var CLI_VERSION = readCliVersion();
 function reportGeneratorFailure(kind, e) {
   if (e instanceof GeneratorNotInstalledError) {
     console.error(
-      import_chalk2.default.red(`The ${kind} generator is not installed.`),
-      import_chalk2.default.yellow(`
+      import_chalk3.default.red(`The ${kind} generator is not installed.`),
+      import_chalk3.default.yellow(`
 Install with: npm install ${e.specifier}`)
     );
     return;
   }
-  console.error(import_chalk2.default.red(`The ${kind} generator failed:`), e?.message ?? e);
+  console.error(import_chalk3.default.red(`The ${kind} generator failed:`), e?.message ?? e);
 }
 var program = new import_commander.Command();
 program.name("drzl").description("DRZL - Drizzle Developer Toolkit").version(CLI_VERSION);
@@ -1531,9 +2107,9 @@ program.command("analyze").argument("<schema>", "path to drizzle schema (TS)").o
     } else if (opts.out) {
       const fs3 = await import("fs/promises");
       await fs3.writeFile(opts.out, json, "utf8");
-      spinner?.succeed(import_chalk2.default.green(`Analysis written to ${opts.out} in ${ms}ms`));
+      spinner?.succeed(import_chalk3.default.green(`Analysis written to ${opts.out} in ${ms}ms`));
     } else {
-      spinner?.succeed(import_chalk2.default.green(`Analyzed in ${ms}ms`));
+      spinner?.succeed(import_chalk3.default.green(`Analyzed in ${ms}ms`));
       console.log(json);
     }
     process.exit(res.issues.some((i) => i.level === "error") ? 2 : 0);
@@ -1543,7 +2119,48 @@ program.command("analyze").argument("<schema>", "path to drizzle schema (TS)").o
       console.log(JSON.stringify({ event: "error", code: "DRZL_CLI_ANALYZE", message: msg }));
     else
       console.error(
-        import_chalk2.default.red("Analyze failed (DRZL_CLI_ANALYZE):"),
+        import_chalk3.default.red("Analyze failed (DRZL_CLI_ANALYZE):"),
+        msg,
+        "\nTip: run with --json for structured output."
+      );
+    process.exit(1);
+  }
+});
+program.command("doctor").description("Report what DRZL cannot type or enforce in your schema, and why").argument("[schema]", "path to drizzle schema (TS); defaults to the schema in drzl.config").option("-c, --config <path>", "path to drzl.config, read when no schema argument is given").option("--json", "print the report as JSON instead of prose", false).option("--strict", "exit 2 when anything is reported", false).action(async (schema, opts) => {
+  try {
+    let target = schema;
+    if (!target) {
+      const cfg = await loadConfig(opts.config);
+      target = cfg?.schema;
+    }
+    if (!target) {
+      const msg = "No schema given. Pass a path, or run from a directory with a drzl.config.";
+      if (opts.json)
+        console.log(JSON.stringify({ event: "error", code: "DRZL_CLI_DOCTOR", message: msg }));
+      else console.error(import_chalk3.default.red("Doctor failed (DRZL_CLI_DOCTOR):"), msg);
+      process.exit(1);
+      return;
+    }
+    const analyzer = new import_analyzer.SchemaAnalyzer(target);
+    const analysis = await analyzer.analyze({
+      includeRelations: true,
+      validateConstraints: true
+    });
+    const report = buildDoctorReport(analysis, target);
+    if (opts.json) console.log(JSON.stringify(report, null, 2));
+    else console.log(renderDoctorReport(report));
+    if (report.findings.some((f) => f.level === "error")) {
+      process.exit(1);
+      return;
+    }
+    process.exit(opts.strict && report.findings.length ? 2 : 0);
+  } catch (e) {
+    const msg = e?.message ?? String(e);
+    if (opts.json)
+      console.log(JSON.stringify({ event: "error", code: "DRZL_CLI_DOCTOR", message: msg }));
+    else
+      console.error(
+        import_chalk3.default.red("Doctor failed (DRZL_CLI_DOCTOR):"),
         msg,
         "\nTip: run with --json for structured output."
       );
@@ -1558,7 +2175,7 @@ program.command("generate").description("Run configured generators (drzl.config.
     const cfg = await loadConfig(opts.config);
     if (!cfg) {
       console.error(
-        import_chalk2.default.red("No config found (DRZL_CFG_001). Create drzl.config.ts or pass --config.")
+        import_chalk3.default.red("No config found (DRZL_CFG_001). Create drzl.config.ts or pass --config.")
       );
       process.exit(2);
       return;
@@ -1603,8 +2220,8 @@ program.command("generate").description("Run configured generators (drzl.config.
           onProgress: ({ index }) => progress.update(index)
         });
         progress.stop();
-        (0, import_ora.default)().succeed(import_chalk2.default.green(`Generated (${g.kind}): ${files.length} files`));
-        files.forEach((f) => console.log("  -", import_chalk2.default.cyan(f)));
+        (0, import_ora.default)().succeed(import_chalk3.default.green(`Generated (${g.kind}): ${files.length} files`));
+        files.forEach((f) => console.log("  -", import_chalk3.default.cyan(f)));
       } else if (g.kind === "trpc") {
         try {
           const { TRPCGenerator: TRPCGenerator2 } = await loadGenerator(
@@ -1617,8 +2234,8 @@ program.command("generate").description("Run configured generators (drzl.config.
             onProgress: ({ index }) => progress.update(index)
           });
           progress.stop();
-          (0, import_ora.default)().succeed(import_chalk2.default.green(`Generated (trpc): ${files.length} files`));
-          files.forEach((f) => console.log("  -", import_chalk2.default.cyan(f)));
+          (0, import_ora.default)().succeed(import_chalk3.default.green(`Generated (trpc): ${files.length} files`));
+          files.forEach((f) => console.log("  -", import_chalk3.default.cyan(f)));
         } catch (e) {
           progress.stop();
           reportGeneratorFailure(g.kind, e);
@@ -1647,8 +2264,8 @@ program.command("generate").description("Run configured generators (drzl.config.
             databaseInjection: g.databaseInjection
           });
           progress.stop();
-          (0, import_ora.default)().succeed(import_chalk2.default.green(`Generated (service): ${files.length} files`));
-          files.forEach((f) => console.log("  -", import_chalk2.default.cyan(f)));
+          (0, import_ora.default)().succeed(import_chalk3.default.green(`Generated (service): ${files.length} files`));
+          files.forEach((f) => console.log("  -", import_chalk3.default.cyan(f)));
         } catch (e) {
           progress.stop();
           reportGeneratorFailure(g.kind, e);
@@ -1666,8 +2283,8 @@ program.command("generate").description("Run configured generators (drzl.config.
             validationOptions(g, cfg, target, { schemaTypes: true })
           );
           progress.stop();
-          (0, import_ora.default)().succeed(import_chalk2.default.green(`Generated (zod): ${files.length} files`));
-          files.forEach((f) => console.log("  -", import_chalk2.default.cyan(f)));
+          (0, import_ora.default)().succeed(import_chalk3.default.green(`Generated (zod): ${files.length} files`));
+          files.forEach((f) => console.log("  -", import_chalk3.default.cyan(f)));
         } catch (e) {
           progress.stop();
           reportGeneratorFailure(g.kind, e);
@@ -1685,8 +2302,8 @@ program.command("generate").description("Run configured generators (drzl.config.
             validationOptions(g, cfg, target, { schemaTypes: true })
           );
           progress.stop();
-          (0, import_ora.default)().succeed(import_chalk2.default.green(`Generated (valibot): ${files.length} files`));
-          files.forEach((f) => console.log("  -", import_chalk2.default.cyan(f)));
+          (0, import_ora.default)().succeed(import_chalk3.default.green(`Generated (valibot): ${files.length} files`));
+          files.forEach((f) => console.log("  -", import_chalk3.default.cyan(f)));
         } catch (e) {
           progress.stop();
           reportGeneratorFailure(g.kind, e);
@@ -1704,8 +2321,8 @@ program.command("generate").description("Run configured generators (drzl.config.
             validationOptions(g, cfg, target, { schemaTypes: false })
           );
           progress.stop();
-          (0, import_ora.default)().succeed(import_chalk2.default.green(`Generated (arktype): ${files.length} files`));
-          files.forEach((f) => console.log("  -", import_chalk2.default.cyan(f)));
+          (0, import_ora.default)().succeed(import_chalk3.default.green(`Generated (arktype): ${files.length} files`));
+          files.forEach((f) => console.log("  -", import_chalk3.default.cyan(f)));
         } catch (e) {
           progress.stop();
           reportGeneratorFailure(g.kind, e);
@@ -1719,15 +2336,10 @@ program.command("generate").description("Run configured generators (drzl.config.
           );
           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,
-            components: g.components
-          });
+          const files = await gen.generate(jsonSchemaOptions(g, cfg, target));
           progress.stop();
-          (0, import_ora.default)().succeed(import_chalk2.default.green(`Generated (json-schema): ${files.length} files`));
-          files.forEach((f) => console.log("  -", import_chalk2.default.cyan(f)));
+          (0, import_ora.default)().succeed(import_chalk3.default.green(`Generated (json-schema): ${files.length} files`));
+          files.forEach((f) => console.log("  -", import_chalk3.default.cyan(f)));
         } catch (e) {
           progress.stop();
           reportGeneratorFailure(g.kind, e);
@@ -1745,8 +2357,8 @@ program.command("generate").description("Run configured generators (drzl.config.
             validationOptions(g, cfg, target, { schemaTypes: true })
           );
           progress.stop();
-          (0, import_ora.default)().succeed(import_chalk2.default.green(`Generated (typebox): ${files.length} files`));
-          files.forEach((f) => console.log("  -", import_chalk2.default.cyan(f)));
+          (0, import_ora.default)().succeed(import_chalk3.default.green(`Generated (typebox): ${files.length} files`));
+          files.forEach((f) => console.log("  -", import_chalk3.default.cyan(f)));
         } catch (e) {
           progress.stop();
           reportGeneratorFailure(g.kind, e);
@@ -1759,22 +2371,22 @@ program.command("generate").description("Run configured generators (drzl.config.
       const drift = diffSnapshots(driftBefore, after);
       await restoreSnapshot(driftBefore, after);
       if (drift.length) {
-        console.error(import_chalk2.default.red(`
+        console.error(import_chalk3.default.red(`
 Generated output is out of date (${drift.length} file(s)):`));
         for (const d of drift) {
           const mark = d.status === "added" ? "+" : d.status === "removed" ? "-" : "~";
           console.error(
-            `  ${mark} ${import_chalk2.default.yellow(d.status.padEnd(8))} ${path5.relative(process.cwd(), d.file)}`
+            `  ${mark} ${import_chalk3.default.yellow(d.status.padEnd(8))} ${path5.relative(process.cwd(), d.file)}`
           );
         }
         console.error(
-          import_chalk2.default.dim(
+          import_chalk3.default.dim(
             "\nRun `drzl generate` and commit the result. Nothing was written by this check."
           )
         );
         process.exit(1);
       }
-      console.log(import_chalk2.default.green("Generated output is up to date."));
+      console.log(import_chalk3.default.green("Generated output is up to date."));
       return;
     }
     if (cfg.generators.length) {
@@ -1782,7 +2394,7 @@ Generated output is out of date (${drift.length} file(s)):`));
     }
   } catch (e) {
     console.error(
-      import_chalk2.default.red("Generate failed (DRZL_GEN_001):"),
+      import_chalk3.default.red("Generate failed (DRZL_GEN_001):"),
       e?.message ?? e,
       "\nTip: check your drzl.config.ts and template path."
     );
@@ -1802,10 +2414,10 @@ program.command("generate:orpc").argument("<schema>", "path to drizzle schema (T
       template: opts.template,
       includeRelations: !!opts.includeRelations
     });
-    console.log(import_chalk2.default.green(`Generated:`), files.map((f) => import_chalk2.default.cyan(f)).join(", "));
+    console.log(import_chalk3.default.green(`Generated:`), files.map((f) => import_chalk3.default.cyan(f)).join(", "));
     maybeShowSponsorMessage({ reason: "generate:orpc" });
   } catch (e) {
-    console.error(import_chalk2.default.red("Generate orpc failed:"), e?.message ?? e);
+    console.error(import_chalk3.default.red("Generate orpc failed:"), e?.message ?? e);
     process.exit(1);
   }
 });
@@ -1829,7 +2441,7 @@ program.command("generate:trpc").argument("<schema>", "path to drizzle schema (T
       // cannot become the branch that forgets it.
       servicesDir: opts.servicesDir
     });
-    console.log(import_chalk2.default.green(`Generated:`), files.map((f) => import_chalk2.default.cyan(f)).join(", "));
+    console.log(import_chalk3.default.green(`Generated:`), files.map((f) => import_chalk3.default.cyan(f)).join(", "));
     maybeShowSponsorMessage({ reason: "generate:trpc" });
   } catch (e) {
     reportGeneratorFailure("trpc", e);
@@ -1839,7 +2451,7 @@ program.command("generate:trpc").argument("<schema>", "path to drizzle schema (T
 program.command("watch").description("Watch schema and regenerate on changes").option("-c, --config <path>", "path to drzl.config").option("--pipeline <name>", "all | analyze | generate-orpc | generate-trpc", "all").option("--debounce <ms>", "debounce ms", "200").option("--json", "emit JSON logs", false).option("--poll", "force polling (helps WSL/Docker/remote FS)", false).action(async (opts) => {
   let cfg = await loadConfig(opts.config);
   if (!cfg) {
-    console.error(import_chalk2.default.red("No config found. Create drzl.config.ts or pass --config."));
+    console.error(import_chalk3.default.red("No config found. Create drzl.config.ts or pass --config."));
     process.exit(2);
     return;
   }
@@ -1931,7 +2543,7 @@ program.command("watch").description("Watch schema and regenerate on changes").o
             })
           );
         } else {
-          console.log(import_chalk2.default.green("Analyze complete."));
+          console.log(import_chalk3.default.green("Analyze complete."));
         }
         return;
       }
@@ -1961,8 +2573,8 @@ program.command("watch").description("Watch schema and regenerate on changes").o
             servicesDir
           });
           opts.json ? console.log(JSON.stringify({ event: "generate_complete", kind: g.kind, files })) : console.log(
-            import_chalk2.default.green(`Generated (${g.kind}):`),
-            files.map((f) => import_chalk2.default.cyan(f)).join(", ")
+            import_chalk3.default.green(`Generated (${g.kind}):`),
+            files.map((f) => import_chalk3.default.cyan(f)).join(", ")
           );
           newFiles.push(...files);
         } else if (g.kind === "trpc") {
@@ -1974,8 +2586,8 @@ program.command("watch").description("Watch schema and regenerate on changes").o
             const gen = new TRPCGenerator2(analysis);
             const { files } = await gen.generate(trpcOptions(g, cfg, servicesDir));
             opts.json ? console.log(JSON.stringify({ event: "generate_complete", kind: g.kind, files })) : console.log(
-              import_chalk2.default.green(`Generated (trpc): ${files.length} files`),
-              files.map((f) => import_chalk2.default.cyan(f)).join(", ")
+              import_chalk3.default.green(`Generated (trpc): ${files.length} files`),
+              files.map((f) => import_chalk3.default.cyan(f)).join(", ")
             );
             newFiles.push(...files);
           } catch (e) {
@@ -2001,8 +2613,8 @@ program.command("watch").description("Watch schema and regenerate on changes").o
               databaseInjection: g.databaseInjection
             });
             opts.json ? console.log(JSON.stringify({ event: "generate_complete", kind: g.kind, files })) : console.log(
-              import_chalk2.default.green(`Generated (service): ${files.length} files`),
-              files.map((f) => import_chalk2.default.cyan(f)).join(", ")
+              import_chalk3.default.green(`Generated (service): ${files.length} files`),
+              files.map((f) => import_chalk3.default.cyan(f)).join(", ")
             );
             newFiles.push(...files);
           } catch (e) {
@@ -2021,8 +2633,8 @@ program.command("watch").description("Watch schema and regenerate on changes").o
               validationOptions(g, cfg, target, { schemaTypes: true })
             );
             opts.json ? console.log(JSON.stringify({ event: "generate_complete", kind: g.kind, files })) : console.log(
-              import_chalk2.default.green(`Generated (zod): ${files.length} files`),
-              files.map((f) => import_chalk2.default.cyan(f)).join(", ")
+              import_chalk3.default.green(`Generated (zod): ${files.length} files`),
+              files.map((f) => import_chalk3.default.cyan(f)).join(", ")
             );
             newFiles.push(...files);
           } catch (e) {
@@ -2041,8 +2653,8 @@ program.command("watch").description("Watch schema and regenerate on changes").o
               validationOptions(g, cfg, target, { schemaTypes: true })
             );
             opts.json ? console.log(JSON.stringify({ event: "generate_complete", kind: g.kind, files })) : console.log(
-              import_chalk2.default.green(`Generated (valibot): ${files.length} files`),
-              files.map((f) => import_chalk2.default.cyan(f)).join(", ")
+              import_chalk3.default.green(`Generated (valibot): ${files.length} files`),
+              files.map((f) => import_chalk3.default.cyan(f)).join(", ")
             );
             newFiles.push(...files);
           } catch (e) {
@@ -2061,8 +2673,8 @@ program.command("watch").description("Watch schema and regenerate on changes").o
               validationOptions(g, cfg, target, { schemaTypes: false })
             );
             opts.json ? console.log(JSON.stringify({ event: "generate_complete", kind: g.kind, files })) : console.log(
-              import_chalk2.default.green(`Generated (arktype): ${files.length} files`),
-              files.map((f) => import_chalk2.default.cyan(f)).join(", ")
+              import_chalk3.default.green(`Generated (arktype): ${files.length} files`),
+              files.map((f) => import_chalk3.default.cyan(f)).join(", ")
             );
             newFiles.push(...files);
           } catch (e) {
@@ -2081,8 +2693,8 @@ program.command("watch").description("Watch schema and regenerate on changes").o
               validationOptions(g, cfg, target, { schemaTypes: true })
             );
             opts.json ? console.log(JSON.stringify({ event: "generate_complete", kind: g.kind, files })) : console.log(
-              import_chalk2.default.green(`Generated (typebox): ${files.length} files`),
-              files.map((f) => import_chalk2.default.cyan(f)).join(", ")
+              import_chalk3.default.green(`Generated (typebox): ${files.length} files`),
+              files.map((f) => import_chalk3.default.cyan(f)).join(", ")
             );
             newFiles.push(...files);
           } catch (e) {
@@ -2097,15 +2709,10 @@ program.command("watch").description("Watch schema and regenerate on changes").o
             );
             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,
-              components: g.components
-            });
+            const files = await gen.generate(jsonSchemaOptions(g, cfg, target));
             opts.json ? console.log(JSON.stringify({ event: "generate_complete", kind: g.kind, files })) : console.log(
-              import_chalk2.default.green(`Generated (json-schema): ${files.length} files`),
-              files.map((f) => import_chalk2.default.cyan(f)).join(", ")
+              import_chalk3.default.green(`Generated (json-schema): ${files.length} files`),
+              files.map((f) => import_chalk3.default.cyan(f)).join(", ")
             );
             newFiles.push(...files);
           } catch (e) {
@@ -2117,8 +2724,8 @@ program.command("watch").description("Watch schema and regenerate on changes").o
       const added = newFiles.filter((f) => !lastFiles.includes(f));
       const removed = lastFiles.filter((f) => !newFiles.includes(f));
       opts.json ? console.log(JSON.stringify({ event: "diff", added, removed })) : (() => {
-        if (added.length) console.log(import_chalk2.default.blue(`Added: ${added.join(", ")}`));
-        if (removed.length) console.log(import_chalk2.default.yellow(`Removed: ${removed.join(", ")}`));
+        if (added.length) console.log(import_chalk3.default.blue(`Added: ${added.join(", ")}`));
+        if (removed.length) console.log(import_chalk3.default.yellow(`Removed: ${removed.join(", ")}`));
       })();
       if (newFiles.length && !opts.json) {
         const reason = opts.pipeline && opts.pipeline !== "all" ? `watch:${opts.pipeline}` : "watch";
@@ -2126,7 +2733,7 @@ program.command("watch").description("Watch schema and regenerate on changes").o
       }
       lastFiles = newFiles;
     } catch (e) {
-      opts.json ? console.log(JSON.stringify({ event: "error", message: String(e?.message ?? e) })) : console.error(import_chalk2.default.red("Watch pipeline failed:"), e?.message ?? e);
+      opts.json ? console.log(JSON.stringify({ event: "error", message: String(e?.message ?? e) })) : console.error(import_chalk3.default.red("Watch pipeline failed:"), e?.message ?? e);
     }
   };
   const debounced = Number(opts.debounce) || 200;
@@ -2151,12 +2758,12 @@ program.command("watch").description("Watch schema and regenerate on changes").o
     );
   } else {
     console.log(
-      import_chalk2.default.gray(
+      import_chalk3.default.gray(
         "Watching:\n  " + Array.from(currentTargets).map((p) => path5.relative(process.cwd(), p)).join("\n  ")
       )
     );
   }
-  watcher.on("add", (p) => trigger(p)).on("change", (p) => trigger(p)).on("unlink", (p) => trigger(p)).on("error", (err) => console.error(import_chalk2.default.red("Watcher error:"), err));
+  watcher.on("add", (p) => trigger(p)).on("change", (p) => trigger(p)).on("unlink", (p) => trigger(p)).on("error", (err) => console.error(import_chalk3.default.red("Watcher error:"), err));
   await run();
 });
 program.command("init").description("Scaffold a drzl.config.ts").option("-y, --yes", "accept defaults").action(async (_opts) => {
@@ -2176,9 +2783,9 @@ program.command("init").description("Scaffold a drzl.config.ts").option("-y, --y
 `;
   try {
     await fs3.writeFile(target, template, { flag: "wx" });
-    console.log(import_chalk2.default.green(`Created ${target}`));
+    console.log(import_chalk3.default.green(`Created ${target}`));
   } catch (e) {
-    console.error(import_chalk2.default.red("Init failed:"), e?.message ?? e);
+    console.error(import_chalk3.default.red("Init failed:"), e?.message ?? e);
     process.exit(1);
   }
 });
@@ -2186,13 +2793,14 @@ function reportWideColumns(issues) {
   const wide = issues.filter((i) => i.code === "DRZL_ANL_UNKNOWN_COLUMN");
   if (!wide.length) return;
   console.warn(
-    import_chalk2.default.yellow(`
+    import_chalk3.default.yellow(`
 ${wide.length} column${wide.length === 1 ? "" : "s"} could not be typed:`)
   );
-  for (const i of wide.slice(0, 10)) console.warn(import_chalk2.default.gray(`  - ${i.message}`));
-  if (wide.length > 10) console.warn(import_chalk2.default.gray(`  ... and ${wide.length - 10} more`));
+  for (const i of wide.slice(0, 10)) console.warn(import_chalk3.default.gray(`  - ${i.message}`));
+  if (wide.length > 10) console.warn(import_chalk3.default.gray(`  ... and ${wide.length - 10} more`));
   const hints = [...new Set(wide.map((i) => i.hint).filter(Boolean))];
-  for (const h of hints) console.warn(import_chalk2.default.gray(`  ${h}`));
+  for (const h of hints) console.warn(import_chalk3.default.gray(`  ${h}`));
+  console.warn(import_chalk3.default.gray("  Run `drzl doctor` for the full report."));
 }
 program.parseAsync(process.argv);
 //# sourceMappingURL=cli.cjs.map