@geonosis/release 1.1.0 → 1.2.0

package/README.md

@@ -17,6 +17,10 @@ geonosis-release migrations --since <ref> [--dialect <name>] [--root <dir>] [--j
 
 Exit **0** clean · **1** refusals · **2** the run could not be made.
 
+## What it reads
+
+The files added since `--since <ref>` — committed, **staged, and untracked** — under every configured `release.migrations[].dir`. A migration that exists and narrows is a refusal whatever git thinks of it: the local gate a person runs before committing is the one window in which it is still free to fix, and a gate that only speaks after the commit speaks after the cheap moment has passed. A run that finds no migration file anywhere says `NONE … nothing was read`, never `OK`.
+
 ## `migrations` — expand-only, enforced
 
 For every file the diff ADDED under a directory `geonosis.json` names, in the dialect it names it

package/dist/{chunk-2JLVQK7Y.js → chunk-BOTEFN3W.js}

@@ -191,9 +191,9 @@ var arrayTable = (into, path) => {
 var parseToml = (source) => {
   const out = {};
   let here = out;
-  const lines = source.split("\n");
-  for (let index = 0; index < lines.length; index += 1) {
-    const line = (lines[index] ?? "").split("#")[0]?.trim() ?? "";
+  const lines2 = source.split("\n");
+  for (let index = 0; index < lines2.length; index += 1) {
+    const line = (lines2[index] ?? "").split("#")[0]?.trim() ?? "";
     if (line === "") continue;
     if (line.startsWith("[[") && line.endsWith("]]")) {
       here = arrayTable(out, line.slice(2, -2).trim().split("."));
@@ -208,9 +208,9 @@ var parseToml = (source) => {
     let text = line.slice(at + 1);
     while ([...text].filter((one) => one === "[").length > [...text].filter((one) => one === "]").length) {
       index += 1;
-      if (index >= lines.length) throw new CannotRun("an unterminated array in the TOML config");
+      if (index >= lines2.length) throw new CannotRun("an unterminated array in the TOML config");
       text += `
-${(lines[index] ?? "").split("#")[0] ?? ""}`;
+${(lines2[index] ?? "").split("#")[0] ?? ""}`;
     }
     put(here, line.slice(0, at).trim().split("."), value(text));
   }
@@ -353,7 +353,13 @@ var git = (root, args) => {
     throw new CannotRun(`git ${args.join(" ")} failed: ${(error.message ?? "").trim()}`);
   }
 };
-var addedSince = (root, since) => git(root, ["diff", "--name-only", "--diff-filter=A", `${since}..HEAD`]).split("\n").filter((line) => line !== "");
+var lines = (out) => out.split("\n").filter((line) => line !== "");
+var addedSince = (root, since) => {
+  const committed = lines(git(root, ["diff", "--name-only", "--diff-filter=A", `${since}..HEAD`]));
+  const staged = lines(git(root, ["diff", "--name-only", "--diff-filter=A", "--cached"]));
+  const untracked = lines(git(root, ["ls-files", "--others", "--exclude-standard"]));
+  return [.../* @__PURE__ */ new Set([...committed, ...staged, ...untracked])].toSorted();
+};
 var gitOk = (root, args) => {
   const run = spawnSync("git", [...args], { cwd: root, encoding: "utf8" });
   return run.error === void 0 && run.status === 0;
@@ -604,12 +610,17 @@ var EXTENSION = {
 var under = (dir, file) => file === dir || file.startsWith(dir.endsWith("/") ? dir : `${dir}/`);
 var fromTypeScript = (path, source, entry) => {
   try {
-    return addSqlIn(source, entry.phases ?? ["up"]).flatMap(
-      (one) => refusalsIn(path, one.sql, one.line)
-    );
+    return {
+      refusals: addSqlIn(source, entry.phases ?? ["up"]).flatMap(
+        (one) => refusalsIn(path, one.sql, one.line)
+      )
+    };
   } catch (error) {
     if (error instanceof Unreadable) {
-      throw new CannotRun(`${path} holds ${error.message} \u2014 this reader cannot read it`);
+      return {
+        refusals: [],
+        unreadable: `${path} holds ${error.message} \u2014 this reader cannot read it`
+      };
     }
     throw error;
   }
@@ -636,7 +647,9 @@ var runMigrations = (input) => {
   const refusals = [];
   const markers = [];
   const squawk = [];
+  const unreadable = [];
   const forSquawk = [];
+  const states = /* @__PURE__ */ new Map();
   for (const { entry, file } of matched) {
     const source = readFileSync4(resolve5(input.root, file), "utf8");
     const found = markersIn(source);
@@ -646,11 +659,18 @@ var runMigrations = (input) => {
     });
     markers.push(...bad);
     const excused = found.length > 0 && bad.length === 0;
+    states.set(file, excused ? "excused" : "clean");
     if (!excused) {
-      refusals.push(
-        ...entry.dialect === "mikro-orm-ts" ? fromTypeScript(file, source, entry) : refusalsIn(file, source)
-      );
+      const mine = entry.dialect === "mikro-orm-ts" ? fromTypeScript(file, source, entry) : { refusals: refusalsIn(file, source) };
+      if (mine.unreadable !== void 0) {
+        unreadable.push({ path: file, why: mine.unreadable });
+        states.set(file, "unreadable");
+        continue;
+      }
+      refusals.push(...mine.refusals);
+      if (mine.refusals.length > 0) states.set(file, "refused");
     }
+    if (bad.length > 0) states.set(file, "refused");
     if (entry.dialect !== "sqlite")
       forSquawk.push({ entry, file, sql: sqlFor(file, source, entry) });
   }
@@ -670,6 +690,7 @@ var runMigrations = (input) => {
         if (!found.ok) {
           clean = false;
           squawk.push({ findings: found.findings, path: one.file });
+          if (states.get(one.file) === "clean") states.set(one.file, "findings");
         }
       }
     } finally {
@@ -677,14 +698,18 @@ var runMigrations = (input) => {
     }
   }
   return {
+    dirs: entries.map((one) => one.dir),
+    files: matched.map(({ file }) => ({ path: file, state: states.get(file) ?? "clean" })),
     linted: forSquawk.length,
     markers: markers.toSorted((a, b) => a.path.localeCompare(b.path) || a.line - b.line),
-    ok: refusals.length === 0 && markers.length === 0 && clean,
-    read: matched.length,
+    ok: refusals.length === 0 && markers.length === 0 && clean && unreadable.length === 0,
+    read: matched.length - unreadable.length,
+    since: input.since,
     refusals: refusals.toSorted(
       (a, b) => a.path.localeCompare(b.path) || a.line - b.line || a.verb.localeCompare(b.verb)
     ),
-    squawk
+    squawk,
+    unreadable
   };
 };
 var WHY = `
@@ -695,21 +720,35 @@ is safe now:
   -- contract-migration: <what expanded it, and why nothing reads it any more> since:<ref>
 `;
 var formatMigrations = (report) => {
+  if (report.files.length === 0) {
+    return `NONE  migrations: no migration file was added since ${report.since} \u2014 committed, staged or untracked \u2014 under ${report.dirs.join(", ")}; nothing was read
+`;
+  }
   if (report.ok) {
     return `OK    migrations: expand-only (${String(report.read)} read, ${String(report.linted)} linted by squawk)
 `;
   }
   const said = report.markers.map((one) => `  ${one.path}: ${one.why} (line ${String(one.line)})
 `);
-  const lines = report.refusals.map(
+  const lines2 = report.refusals.map(
     (one) => `  ${one.path}: ${one.verb} (line ${String(one.line)})
 `
   );
   const found = report.squawk.map((one) => `  ${one.path}:
 ${one.findings}
+`);
+  const cannot = report.unreadable.map((one) => `  ${one.why}
 `);
   const why = report.markers.length + report.refusals.length === 0 ? "" : WHY;
-  return `${said.join("")}${lines.join("")}${why}${found.join("")}`;
+  return `${said.join("")}${lines2.join("")}${cannot.join("")}${why}${found.join("")}${accounting(report)}`;
+};
+var accounting = (report) => {
+  const total = report.files.length;
+  const by = (state) => report.files.filter((one) => one.state === state).length;
+  const rows = report.files.map((one) => `  ${one.state.padEnd(10)} ${one.path}
+`);
+  return `${rows.join("")}migrations: ${String(report.read)} of ${String(total)} files read \u2014 ${String(by("refused"))} refused, ${String(by("findings"))} with squawk findings, ${String(by("excused"))} excused, ${String(by("clean"))} clean${report.unreadable.length === 0 ? "" : `, ${String(report.unreadable.length)} unreadable`}
+`;
 };
 
 // src/plan.ts
@@ -871,7 +910,7 @@ var stubPath = () => {
   return path;
 };
 var prove = async (cwd, stub = stubPath()) => {
-  const lines = [];
+  const lines2 = [];
   let ok = true;
   for (const plant of PLANTS) {
     const verdict = await proveOver({
@@ -881,10 +920,10 @@ var prove = async (cwd, stub = stubPath()) => {
       timeoutMs: 3e4
     });
     if (verdict.ok) ok = false;
-    lines.push(`  ${verdict.ok ? "MISSED" : "PROVEN"} ${plant.says}`);
+    lines2.push(`  ${verdict.ok ? "MISSED" : "PROVEN"} ${plant.says}`);
     if (plant.name !== "promoted" && verdict.steps.includes("promote")) {
       ok = false;
-      lines.push("  MISSED a refused smoke was followed by a promote request");
+      lines2.push("  MISSED a refused smoke was followed by a promote request");
     }
   }
   const honest = await proveOver({
@@ -894,10 +933,10 @@ var prove = async (cwd, stub = stubPath()) => {
     timeoutMs: 3e4
   });
   if (!honest.ok) ok = false;
-  lines.push(
+  lines2.push(
     `  ${honest.ok ? "PROVEN" : "MISSED"} a smoke that answered the version it overrode to is not refused`
   );
-  return { lines, ok };
+  return { lines: lines2, ok };
 };
 var formatProve = (outcome) => `${outcome.lines.join("\n")}
 

package/dist/index.d.ts

@@ -37,16 +37,30 @@ type MarkerRefusal = {
     path: string;
     why: string;
 };
+type FileState = 'clean' | 'excused' | 'findings' | 'refused' | 'unreadable';
 type MigrationsReport = {
+    /** The configured directories the run looked under. */
+    dirs: string[];
+    /** Every file the diff added under a configured dir, by name and state — a clean file included. */
+    files: {
+        path: string;
+        state: FileState;
+    }[];
     linted: number;
     markers: MarkerRefusal[];
     ok: boolean;
     read: number;
     refusals: Refusal[];
+    since: string;
     squawk: {
         findings: string;
         path: string;
     }[];
+    /** Files this reader could not read: named, never a stop for the others. */
+    unreadable: {
+        path: string;
+        why: string;
+    }[];
 };
 
 declare const parseReleaseConfig: (raw: unknown) => ReleaseConfig;

package/dist/index.js

@@ -28,7 +28,7 @@ import {
   runMigrations,
   runPlan,
   statementsOf
-} from "./chunk-2JLVQK7Y.js";
+} from "./chunk-BOTEFN3W.js";
 export {
   DEPLOYED_FILE,
   NARROWING,

package/dist/release-cli.js

@@ -10,7 +10,7 @@ import {
   runDeployed,
   runMigrations,
   runPlan
-} from "./chunk-2JLVQK7Y.js";
+} from "./chunk-BOTEFN3W.js";
 
 // src/release-cli.ts
 import { resolve } from "path";
@@ -93,6 +93,7 @@ var migrations = (parsed, cwd) => {
     parsed.json ? `${JSON.stringify(report, void 0, 2)}
 ` : formatMigrations(report)
   );
+  if (report.unreadable.length > 0) return 2;
   return report.ok ? 0 : 1;
 };
 var plan = (parsed, cwd) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geonosis/release",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "types": "./dist/index.d.ts",
   "description": "The release contract with its proofs: an expand-only migration gate over three dialects, a smoke that must name the version that answered it, and declared ≠ deployed.",
   "keywords": [