@drzl/cli 4.32.0 → 4.35.0

package/dist/cli.js

@@ -13,6 +13,7 @@ import {
   effectHttpOutDir,
   elysiaOutDir,
   expressOutDir,
+  fastCheckOutDir,
   fastifyOutDir,
   filterTables,
   graphqlOutDir,
@@ -27,12 +28,13 @@ import {
   nearestKey,
   nestjsOutDir,
   nextOutDir,
+  seedOutDir,
   tableAliases,
   tableFilterWarnings,
   tanstackStartOutDir,
   trpcOutDir,
   tsRestOutDir
-} from "./chunk-BDIJ6WMG.js";
+} from "./chunk-S5JWTWWU.js";
 
 // src/cli.ts
 import { qualifiedTableName as qualifiedTableName2, SchemaAnalyzer as SchemaAnalyzer2 } from "@drzl/analyzer";
@@ -443,6 +445,29 @@ function elysiaOptions(g, cfg) {
   };
 }
 
+// src/seed-options.ts
+function seedOptions(g, cfg) {
+  return {
+    outputDir: seedOutDir(g, cfg),
+    defaultCount: g.count,
+    naming: g.naming,
+    outputHeader: g.outputHeader,
+    format: g.format,
+    importExtension: g.importExtension
+  };
+}
+
+// src/fast-check-options.ts
+function fastCheckOptions(g, cfg) {
+  return {
+    outputDir: fastCheckOutDir(g, cfg),
+    naming: g.naming,
+    outputHeader: g.outputHeader,
+    format: g.format,
+    importExtension: g.importExtension
+  };
+}
+
 // src/h3-options.ts
 var VALIDATOR_DEFAULT_DIRS4 = {
   zod: "src/validators/zod",
@@ -768,6 +793,22 @@ var GENERATORS = [
     outputDir: (g, cfg) => elysiaOutDir(g, cfg),
     options: (g, cfg) => elysiaOptions(g, cfg)
   },
+  {
+    kind: "seed",
+    specifier: "@drzl/generator-seed",
+    load: () => import("@drzl/generator-seed"),
+    construct: (m, analysis) => new m.SeedGenerator(analysis),
+    outputDir: (g, cfg) => seedOutDir(g, cfg),
+    options: (g, cfg) => seedOptions(g, cfg)
+  },
+  {
+    kind: "fast-check",
+    specifier: "@drzl/generator-fast-check",
+    load: () => import("@drzl/generator-fast-check"),
+    construct: (m, analysis) => new m.FastCheckGenerator(analysis),
+    outputDir: (g, cfg) => fastCheckOutDir(g, cfg),
+    options: (g, cfg) => fastCheckOptions(g, cfg)
+  },
   {
     kind: "service",
     specifier: "@drzl/generator-service",
@@ -2109,6 +2150,180 @@ async function resolveSchemaSource(cfg, cwd = process.cwd()) {
   };
 }
 
+// src/constraint-drift.ts
+import { tableConstraints as tableConstraints2 } from "@drzl/validation-core";
+import { Chalk as Chalk4 } from "chalk";
+var PLAIN3 = new Chalk4({ level: 0 });
+var PLAIN_TEXT_TYPES = /* @__PURE__ */ new Set([
+  "text",
+  "varchar",
+  "character varying",
+  "char",
+  "character",
+  "bpchar",
+  "citext",
+  "tinytext",
+  "mediumtext",
+  "longtext",
+  "nvarchar",
+  "nchar"
+]);
+function typeStem(sqlType) {
+  return sqlType.replace(/\(.*$/, "").replace(/\[\]$/, "").trim().toLowerCase();
+}
+function isSchemaOnlyEnum(column) {
+  if (!column.enumValues || column.enumValues.length === 0) return false;
+  if (!column.sqlType) return false;
+  return PLAIN_TEXT_TYPES.has(typeStem(column.sqlType));
+}
+function sqlLiterals(values) {
+  return values.map((v) => `'${v.replace(/'/g, "''")}'`).join(", ");
+}
+function derivedName(table, column) {
+  return `${table}_${column}_check`;
+}
+function buildConstraintDriftReport(analysis, schemaPath) {
+  const entries = [];
+  for (const table of analysis.tables) {
+    for (const c of tableConstraints2(table).constraints) {
+      if (c.enforced) {
+        for (const part of c.unenforced ?? []) {
+          entries.push({
+            side: "database-only",
+            table: table.name,
+            columns: [...c.columns],
+            rule: part.part,
+            reason: part.reason,
+            ...c.name ? { constraint: c.name } : {}
+          });
+        }
+        continue;
+      }
+      entries.push({
+        side: "database-only",
+        table: table.name,
+        columns: [...c.columns],
+        rule: c.rule,
+        reason: reasonFor(c.kind, c.unenforced),
+        ...c.name ? { constraint: c.name } : {}
+      });
+    }
+    for (const column of table.columns) {
+      if (!isSchemaOnlyEnum(column)) continue;
+      const values = column.enumValues;
+      entries.push({
+        side: "schema-only",
+        table: table.name,
+        columns: [column.name],
+        rule: `${column.name} IN (${sqlLiterals(values)})`,
+        reason: `the column is declared ${column.sqlType}, which holds any text; the set exists only in the generated schemas`,
+        fix: `ALTER TABLE ${table.name} ADD CONSTRAINT ${derivedName(table.name, column.name)} CHECK (${column.name} IN (${sqlLiterals(values)}));`
+      });
+    }
+  }
+  const databaseOnly = entries.filter((e) => e.side === "database-only").length;
+  const schemaOnly = entries.filter((e) => e.side === "schema-only").length;
+  return {
+    schema: schemaPath,
+    dialect: analysis.dialect,
+    ok: entries.length === 0,
+    counts: { tables: analysis.tables.length, databaseOnly, schemaOnly },
+    entries
+  };
+}
+function reasonFor(kind, unenforced) {
+  if (unenforced && unenforced.length) return unenforced.map((u) => u.reason).join("; ");
+  switch (kind) {
+    case "primaryKey":
+    case "unique":
+      return "whether a value is already taken is a fact about the table, not about one row";
+    case "foreignKey":
+      return "whether the referenced row exists is a question only the database can answer";
+    default:
+      return "no generated schema states it";
+  }
+}
+function wrap3(text, indent, first = indent, width = 96) {
+  const words = text.split(/\s+/).filter(Boolean);
+  const lines = [];
+  let line = first;
+  let started = false;
+  for (const w of words) {
+    if (started && line.length + 1 + w.length > width) {
+      lines.push(line);
+      line = indent + w;
+    } else {
+      line = started ? `${line} ${w}` : line + w;
+      started = true;
+    }
+  }
+  if (started) lines.push(line);
+  return lines.join("\n");
+}
+function renderConstraintDriftReport(report, style = PLAIN3) {
+  const chalk = style;
+  const out = [];
+  const plural = (n, one) => `${n} ${one}${n === 1 ? "" : "s"}`;
+  out.push(chalk.bold(`DRZL constraint drift  ${report.schema}`));
+  out.push(chalk.dim(`${report.dialect}, ${plural(report.counts.tables, "table")}`));
+  out.push("");
+  if (report.ok) {
+    out.push(chalk.green("No drift."));
+    out.push(chalk.dim("  Every constraint the database declares is one the generated schemas state."));
+    out.push(chalk.dim("  Every set the generated schemas restrict is one the database enforces."));
+    return out.join("\n");
+  }
+  const schemaOnly = report.entries.filter((e) => e.side === "schema-only");
+  if (schemaOnly.length) {
+    out.push(chalk.yellow("Your schemas enforce this and the database does not"));
+    out.push(
+      chalk.dim(
+        wrap3(
+          "Any other client writes past these. A migration, a psql session or an admin tool is not running your validators.",
+          "  "
+        )
+      )
+    );
+    out.push("");
+    for (const e of schemaOnly) {
+      out.push(`  ${chalk.dim("-")} ${chalk.bold(e.table)}.${e.columns.join(", ")}`);
+      out.push(wrap3(e.rule, "      "));
+      out.push(chalk.dim(wrap3(e.reason, "      ")));
+      if (e.fix) {
+        out.push(chalk.dim("      Close it with:"));
+        out.push(`      ${e.fix}`);
+      }
+      out.push("");
+    }
+  }
+  const databaseOnly = report.entries.filter((e) => e.side === "database-only");
+  if (databaseOnly.length) {
+    out.push(chalk.cyan("The database enforces this and your schemas do not"));
+    out.push(
+      chalk.dim(
+        wrap3(
+          "Mostly not a defect: a key, a unique index and a foreign key are facts about the table rather than about one row, so no per-row validator can see them. Listed so nobody reads the generated schemas as the whole story.",
+          "  "
+        )
+      )
+    );
+    out.push("");
+    for (const e of databaseOnly) {
+      const name = e.constraint ? ` ${chalk.dim(`(${e.constraint})`)}` : "";
+      out.push(`  ${chalk.dim("-")} ${chalk.bold(e.table)}${name}`);
+      out.push(wrap3(e.rule, "      "));
+      out.push(chalk.dim(wrap3(e.reason, "      ")));
+      out.push("");
+    }
+  }
+  out.push(
+    chalk.dim(
+      `${plural(report.counts.schemaOnly, "gap")} your schemas alone enforce, ${plural(report.counts.databaseOnly, "constraint")} only the database does.`
+    )
+  );
+  return out.join("\n");
+}
+
 // src/drift.ts
 import { promises as fs2 } from "fs";
 import path2 from "path";
@@ -3031,7 +3246,10 @@ withOutputFlags(
   }
 });
 withOutputFlags(
-  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("--strict", "exit 2 when anything is reported", false)
+  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("--strict", "exit 2 when anything is reported", false).option(
+    "--constraints",
+    "report what each side enforces that the other does not, instead of the usual findings"
+  )
 ).action(async (schema, opts) => {
   const out = outputFor(opts);
   {
@@ -3053,10 +3271,34 @@ withOutputFlags(
         includeRelations: true,
         validateConstraints: true
       });
-      const report = buildDoctorReport(
-        analysis,
-        Array.isArray(target) ? target.join(", ") : target
-      );
+      const schemaLabel = Array.isArray(target) ? target.join(", ") : target;
+      if (opts.constraints) {
+        const preflight = buildDoctorReport(analysis, schemaLabel);
+        const fatal = preflight.findings.filter((f) => f.level === "error");
+        if (fatal.length) {
+          if (opts.json)
+            out.data(
+              JSON.stringify(
+                { command: "doctor", exitCode: EXIT_FAILED, ...preflight },
+                null,
+                2
+              )
+            );
+          else out.data(renderDoctorReport(preflight, out.outStyle));
+          process.exit(EXIT_FAILED);
+          return;
+        }
+        const drift = buildConstraintDriftReport(analysis, schemaLabel);
+        const driftCode = opts.strict && drift.counts.schemaOnly ? EXIT_FINDINGS : EXIT_OK;
+        if (opts.json)
+          out.data(
+            JSON.stringify({ command: "doctor", exitCode: driftCode, ...drift }, null, 2)
+          );
+        else out.data(renderConstraintDriftReport(drift, out.outStyle));
+        process.exit(driftCode);
+        return;
+      }
+      const report = buildDoctorReport(analysis, schemaLabel);
       const unreadable = report.findings.some((f) => f.level === "error");
       const code = unreadable ? EXIT_FAILED : opts.strict && report.findings.length ? EXIT_FINDINGS : EXIT_OK;
       if (opts.json)