@biffo/cli 0.47.0 → 0.49.0

package/core.version

@@ -1 +1 @@
-0.47.0
+0.49.0

package/dist/index.js

@@ -1304,20 +1304,54 @@ function chainOrder(migrations) {
 function reissuedRevisionId(file) {
   return `core_${createHash("sha256").update(file).digest("hex").slice(0, 8)}`;
 }
+var CARRIED_FROM_MARKER = "# biffo:carried-from:";
+var CARRIED_FROM_RE = /^# biffo:carried-from:[ \t]*(\S+)[ \t]*$/m;
+function parseCarriedFrom(content) {
+  return CARRIED_FROM_RE.exec(content)?.[1] ?? null;
+}
+function stampCarriedFrom(content, templateFile) {
+  if (CARRIED_FROM_RE.test(content)) return content;
+  return content.replace(REVISION_RE, (m) => `${CARRIED_FROM_MARKER} ${templateFile}
+${m}`);
+}
+function migrationBodyHash(content) {
+  const normalised = content.split("\n").map((line) => line.trimEnd()).filter(
+    (line) => !REVISION_RE.test(line) && !DOWN_REVISION_RE.test(line) && !CARRIED_FROM_RE.test(line) && // No trailing space in the patterns: lines are trimEnd()ed first, and a
+    // base migration's `Revises: ` is empty, so requiring the space would
+    // leave that one line in and give every base migration a hash of its
+    // own — a difference in chaining metadata masquerading as a difference
+    // in DDL.
+    !/^Revision ID:/.test(line) && !/^Revises:/.test(line) && !/^Create Date:/.test(line) && line !== ""
+  ).join("\n");
+  return createHash("sha256").update(normalised).digest("hex");
+}
+function migrationSlug(file) {
+  return file.replace(/\.py$/, "").replace(/^[0-9a-f]+_/i, "");
+}
 function planMigrationCarry(options) {
   const templateVersions = join5(options.templateDir, MIGRATIONS_VERSIONS_DIR);
   const instanceVersions = join5(options.instanceDir, MIGRATIONS_VERSIONS_DIR);
   const template = readMigrations(templateVersions);
   const instance = readMigrations(instanceVersions);
   const instanceHead = validateChain(instance, `${MIGRATIONS_VERSIONS_DIR} (instance)`);
-  const instanceFiles = new Set(instance.map((m) => m.file));
   const usedRevisions = new Set(instance.map((m) => m.revision));
+  const identity = indexInstanceMigrations(instance);
+  const templateBodyCounts = /* @__PURE__ */ new Map();
+  for (const m of template) {
+    const body = migrationBodyHash(m.content);
+    templateBodyCounts.set(body, (templateBodyCounts.get(body) ?? 0) + 1);
+  }
   const entries = [];
   const skipped = [];
+  const recognised = [];
   let head = instanceHead;
   for (const m of chainOrder(template)) {
-    if (instanceFiles.has(m.file)) {
+    const already = alreadyCarried(m, identity, templateBodyCounts);
+    if (already) {
       skipped.push(m.file);
+      if (already.how !== "filename") {
+        recognised.push({ file: m.file, instanceFile: already.instance.file, how: already.how });
+      }
       continue;
     }
     let revision = m.revision;
@@ -1337,7 +1371,9 @@ function planMigrationCarry(options) {
       file: m.file,
       revision,
       downRevision: head,
-      content: rechainMigration(m.content, revision, head)
+      // Stamped before re-chaining so the instance's copy records which template
+      // migration it is, whatever it is later renamed or renumbered to.
+      content: rechainMigration(stampCarriedFrom(m.content, m.file), revision, head)
     };
     if (reissuedFrom !== void 0) entry.reissuedFrom = reissuedFrom;
     entries.push(entry);
@@ -1356,7 +1392,56 @@ function planMigrationCarry(options) {
     ],
     `${MIGRATIONS_VERSIONS_DIR} (after carry)`
   );
-  return { entries, instanceHead, skipped };
+  return { entries, instanceHead, skipped, recognised };
+}
+function indexInstanceMigrations(instance) {
+  const index = {
+    byCarriedFrom: /* @__PURE__ */ new Map(),
+    byFile: /* @__PURE__ */ new Map(),
+    byBody: /* @__PURE__ */ new Map(),
+    bySlug: /* @__PURE__ */ new Map()
+  };
+  for (const m of instance) {
+    index.byFile.set(m.file, m);
+    const from = parseCarriedFrom(m.content);
+    if (from !== null) index.byCarriedFrom.set(from, m);
+    const body = migrationBodyHash(m.content);
+    index.byBody.set(body, [...index.byBody.get(body) ?? [], m]);
+    const slug = migrationSlug(m.file);
+    index.bySlug.set(slug, [...index.bySlug.get(slug) ?? [], m]);
+  }
+  return index;
+}
+function alreadyCarried(m, index, templateBodyCounts) {
+  const byProvenance = index.byCarriedFrom.get(m.file);
+  if (byProvenance) return { instance: byProvenance, how: "provenance" };
+  const byFile = index.byFile.get(m.file);
+  if (byFile) return { instance: byFile, how: "filename" };
+  const body = migrationBodyHash(m.content);
+  const bodyMatches = index.byBody.get(body) ?? [];
+  if (bodyMatches.length === 1 && templateBodyCounts.get(body) === 1) {
+    return { instance: bodyMatches[0], how: "body" };
+  }
+  const slugMatches = (index.bySlug.get(migrationSlug(m.file)) ?? []).filter(
+    // A file already claimed as a copy of some OTHER template migration is not
+    // an ambiguous match for this one.
+    (candidate) => parseCarriedFrom(candidate.content) === null
+  );
+  if (slugMatches.length > 0) {
+    const names = slugMatches.map((c) => c.file).join(", ");
+    throw new Error(
+      `Cannot carry ${m.file}: the instance has ${names}, which describes the same migration but whose contents differ, and which carries no provenance marker. Refusing to guess.
+
+  If it IS this migration (carried before provenance was recorded, then renamed or edited), add this line above its 'revision' assignment and re-run:
+
+      ${CARRIED_FROM_MARKER} ${m.file}
+
+  If it is unrelated, rename it so the descriptions differ.
+
+  Carrying it blindly would re-issue an already-applied migration and run its DDL against a database that already has those objects (#366).`
+    );
+  }
+  return null;
 }
 function applyMigrationCarry(instanceDir, plan) {
   const written = [];
@@ -1798,6 +1883,11 @@ var STATUS_COLOR = {
   "keep-ours": chalk4.dim
 };
 function printMigrationCarry(migrations) {
+  for (const r of migrations.recognised) {
+    console.log(
+      `  ${chalk4.dim("already carried".padEnd(15))} ${r.file} ` + chalk4.dim(`\u2192 this instance calls it ${r.instanceFile} (matched by ${r.how})`)
+    );
+  }
   for (const e of migrations.entries) {
     const suffix = e.reissuedFrom ? chalk4.dim(
       ` (revision ${e.revision}, re-issued from ${e.reissuedFrom}; revises ${e.downRevision ?? "base"})`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@biffo/cli",
-  "version": "0.47.0",
+  "version": "0.49.0",
   "description": "Biffo project scaffolding CLI",
   "license": "MIT",
   "type": "module",