@drzl/cli 4.32.0 → 4.35.0

package/dist/cli.cjs

@@ -515,6 +515,8 @@ var GeneratorKindSchema = import_zod.z.enum([
   "next",
   "tanstack-start",
   "ts-rest",
+  "seed",
+  "fast-check",
   "service",
   "zod",
   "valibot",
@@ -559,6 +561,8 @@ var GeneratorSchema = import_zod.z.object({
   contractName: import_zod.z.string().optional(),
   /** The identifier the assembled Elysia app is exported as. `elysia` only, defaults to `'app'`. */
   appName: import_zod.z.string().optional(),
+  /** How many rows each generated seed function returns by default. `seed` only, defaults to 10. */
+  count: import_zod.z.number().int().positive().optional(),
   /**
    * Prefixed to every table's mount point. `elysia` only.
    *
@@ -1028,6 +1032,12 @@ function tsRestOutDir(g, cfg) {
 function elysiaOutDir(g, cfg) {
   return g.path ?? cfg.outDir;
 }
+function seedOutDir(g, cfg) {
+  return g.path ?? cfg.outDir;
+}
+function fastCheckOutDir(g, cfg) {
+  return g.path ?? cfg.outDir;
+}
 function sharedSchemaNames(opts) {
   const resolved = (0, import_validation_core.resolveAffix)(opts);
   return import_validation_core.NAME_MODES.map((mode) => (0, import_validation_core.schemaName)(mode, import_validation_core.AFFIX_PROBE_TABLE, resolved));
@@ -1344,6 +1354,8 @@ function computeGeneratorOutputDirs(cfg, cwd = process.cwd()) {
     if (g.kind === "effect-http") dirs.add(abs(effectHttpOutDir(g, cfg)));
     if (g.kind === "ts-rest") dirs.add(abs(tsRestOutDir(g, cfg)));
     if (g.kind === "elysia") dirs.add(abs(elysiaOutDir(g, cfg)));
+    if (g.kind === "seed") dirs.add(abs(seedOutDir(g, cfg)));
+    if (g.kind === "fast-check") dirs.add(abs(fastCheckOutDir(g, cfg)));
     if (g.kind === "service") dirs.add(abs(g.path ?? "src/services"));
     if (g.kind === "zod") dirs.add(abs(g.path ?? "src/validators/zod"));
     if (g.kind === "valibot") dirs.add(abs(g.path ?? "src/validators/valibot"));
@@ -1627,6 +1639,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",
@@ -1952,6 +1987,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",
@@ -3293,6 +3344,180 @@ async function resolveSchemaSource(cfg, cwd = process.cwd()) {
   };
 }
 
+// src/constraint-drift.ts
+var import_validation_core5 = require("@drzl/validation-core");
+var import_chalk4 = require("chalk");
+var PLAIN3 = new import_chalk4.Chalk({ 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 (0, import_validation_core5.tableConstraints)(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
 var import_node_fs = require("fs");
 var import_node_path = __toESM(require("path"), 1);
@@ -4215,7 +4440,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);
   {
@@ -4237,10 +4465,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)