@drzl/cli 4.34.0 → 4.36.0

package/dist/cli.js

@@ -2150,6 +2150,240 @@ 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`;
+}
+var ADD_CONSTRAINT_DIALECTS = /* @__PURE__ */ new Set([
+  "postgres",
+  "cockroach",
+  "gel",
+  "mysql",
+  "singlestore",
+  "mssql"
+]);
+function fixFor(dialect, table, column, values) {
+  if (!ADD_CONSTRAINT_DIALECTS.has(dialect)) return void 0;
+  return `ALTER TABLE ${table} ADD CONSTRAINT ${derivedName(table, column)} CHECK (${column} IN (${sqlLiterals(values)}));`;
+}
+function noFixReason(dialect) {
+  if (dialect === "sqlite") {
+    return "SQLite cannot add a CHECK to an existing column: ALTER TABLE ... ADD CONSTRAINT is a syntax error there. Closing this means rebuilding the table, which is the twelve-step procedure SQLite documents: create the new table with the constraint, copy the rows, drop the old one, rename.";
+  }
+  return `no statement is emitted for the "${dialect}" dialect, which this report cannot name a fix for`;
+}
+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`,
+        ...(() => {
+          const fix = fixFor(analysis.dialect, table.name, column.name, values);
+          return fix ? { fix } : { noFix: noFixReason(analysis.dialect) };
+        })()
+      });
+    }
+  }
+  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}`);
+      } else if (e.noFix) {
+        out.push(chalk.dim(wrap3(e.noFix, "      ", "      Not one statement here: ")));
+      }
+      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");
+}
+function renderConstraintDriftSql(report) {
+  const gaps = report.entries.filter((e) => e.side === "schema-only");
+  if (!gaps.length) return "";
+  const out = [];
+  const runnable = gaps.filter((g) => g.fix);
+  const unrunnable = gaps.filter((g) => !g.fix);
+  out.push(`-- Generated by drzl doctor --constraints --sql`);
+  out.push(`-- ${report.schema}, ${report.dialect}`);
+  out.push(
+    `-- ${runnable.length} constraint(s) your schemas enforce and the database does not.`
+  );
+  if (unrunnable.length) {
+    out.push(
+      `-- ${unrunnable.length} more cannot be closed by one statement on this dialect; see below.`
+    );
+  }
+  out.push("");
+  const byPlace = (a, b) => a.table.localeCompare(b.table) || a.columns.join().localeCompare(b.columns.join());
+  for (const g of [...runnable].sort(byPlace)) {
+    out.push(`-- ${g.table}.${g.columns.join(", ")}: ${g.reason}`);
+    out.push(g.fix);
+    out.push("");
+  }
+  if (unrunnable.length) {
+    out.push("-- The rest, which this dialect cannot do in one statement:");
+    for (const g of [...unrunnable].sort(byPlace)) {
+      out.push(`--`);
+      out.push(`--   ${g.table}.${g.columns.join(", ")}`);
+      out.push(`--   ${g.rule}`);
+      for (const line of (g.noFix ?? "").match(/.{1,88}(\s|$)/g) ?? []) {
+        out.push(`--   ${line.trim()}`);
+      }
+    }
+    out.push("");
+  }
+  return out.join("\n");
+}
+
 // src/drift.ts
 import { promises as fs2 } from "fs";
 import path2 from "path";
@@ -3072,7 +3306,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"
+  ).option("--sql", "with --constraints, emit the statements alone, for redirecting to a migration")
 ).action(async (schema, opts) => {
   const out = outputFor(opts);
   {
@@ -3094,10 +3331,46 @@ 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.sql && !opts.constraints) {
+        const msg = "--sql reports the constraint drift as statements, so it needs --constraints.";
+        if (opts.json) out.jsonData(jsonFailure("doctor", "DRZL_CLI_DOCTOR", msg));
+        else out.error("Doctor failed (DRZL_CLI_DOCTOR):", msg);
+        process.exit(EXIT_FAILED);
+        return;
+      }
+      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.sql) {
+          out.data(renderConstraintDriftSql(drift));
+          process.exit(driftCode);
+          return;
+        }
+        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)