@tenonhq/dovetail-core 0.0.103 → 0.0.105

package/dist/tests/reconcileDeleteOrder.test.js

@@ -0,0 +1,70 @@
+"use strict";
+// Tests for the multi-pass delete loop: clean deletes, emergent FK ordering
+// (a record blocked until its dependent is gone), and a genuine failure that
+// survives a no-progress pass and is reported.
+Object.defineProperty(exports, "__esModule", { value: true });
+const deleteOrder_1 = require("../reconcile/deleteOrder");
+const del = (sys_id) => ({
+    kind: "delete",
+    table: "sys_script",
+    scope: "x_cadso_core",
+    sys_id,
+    name: sys_id,
+    fieldDeltas: [],
+    deleteDisposition: "tracked",
+});
+describe("runMultiPassDeletes", () => {
+    it("deletes everything in a single clean pass", async () => {
+        const calls = [];
+        const exec = async (c) => {
+            calls.push(c.sys_id);
+            return { ok: true };
+        };
+        const out = await (0, deleteOrder_1.runMultiPassDeletes)([del("a"), del("b")], exec);
+        expect(out.every((o) => o.ok)).toBe(true);
+        expect(calls.sort()).toEqual(["a", "b"]);
+    });
+    it("resolves FK ordering: parent succeeds only after the child is gone", async () => {
+        // "parent" cannot delete while "child" still exists.
+        const deleted = new Set();
+        const exec = async (c) => {
+            if (c.sys_id === "parent" && !deleted.has("child")) {
+                return { ok: false, error: "still referenced by child" };
+            }
+            deleted.add(c.sys_id);
+            return { ok: true };
+        };
+        // parent is attempted first, fails, then succeeds on the pass after child.
+        const out = await (0, deleteOrder_1.runMultiPassDeletes)([del("parent"), del("child")], exec);
+        expect(out.filter((o) => o.ok).map((o) => o.change.sys_id).sort()).toEqual([
+            "child",
+            "parent",
+        ]);
+        expect(out.every((o) => o.ok)).toBe(true);
+    });
+    it("reports a record that fails for a non-ordering reason", async () => {
+        const exec = async (c) => {
+            if (c.sys_id === "locked") {
+                return { ok: false, error: "ACL blocked" };
+            }
+            return { ok: true };
+        };
+        const out = await (0, deleteOrder_1.runMultiPassDeletes)([del("ok"), del("locked")], exec);
+        const failed = out.filter((o) => !o.ok);
+        expect(failed).toHaveLength(1);
+        expect(failed[0].change.sys_id).toBe("locked");
+        expect(failed[0].error).toBe("ACL blocked");
+    });
+    it("treats a thrown executor error as a failure", async () => {
+        const exec = async () => {
+            throw new Error("network down");
+        };
+        const out = await (0, deleteOrder_1.runMultiPassDeletes)([del("a")], exec);
+        expect(out[0].ok).toBe(false);
+        expect(out[0].error).toBe("network down");
+    });
+    it("returns [] for no changes", async () => {
+        const out = await (0, deleteOrder_1.runMultiPassDeletes)([], async () => ({ ok: true }));
+        expect(out).toEqual([]);
+    });
+});

package/dist/tests/reconcileFields.test.js

@@ -0,0 +1,24 @@
+"use strict";
+// Tests for the field-comparison rules: metaData is excluded from the content
+// diff; everything else is a comparable field with a stable "<name>.<type>" key.
+Object.defineProperty(exports, "__esModule", { value: true });
+const fields_1 = require("../reconcile/fields");
+describe("isComparableField", () => {
+    it("excludes the metaData.json bookkeeping file", () => {
+        expect((0, fields_1.isComparableField)({ name: "metaData", type: "json" })).toBe(false);
+    });
+    it("includes a real field file", () => {
+        expect((0, fields_1.isComparableField)({ name: "script", type: "js" })).toBe(true);
+    });
+    it("includes a json field that is not metaData", () => {
+        expect((0, fields_1.isComparableField)({ name: "composition", type: "json" })).toBe(true);
+    });
+    it("includes a field that happens to be named metaData but is not json", () => {
+        expect((0, fields_1.isComparableField)({ name: "metaData", type: "txt" })).toBe(true);
+    });
+});
+describe("fieldKey", () => {
+    it("joins name and type", () => {
+        expect((0, fields_1.fieldKey)({ name: "script", type: "js" })).toBe("script.js");
+    });
+});

package/dist/tests/reconcileGitignore.test.js

@@ -0,0 +1,51 @@
+"use strict";
+// Tests for the gitignore-ensure compute step plus the I/O wrapper.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const gitignore_1 = require("../reconcile/gitignore");
+const ENTRY = ".dove-reconcile-baseline.json";
+describe("hasGitignoreEntry", () => {
+    it("detects a present entry ignoring surrounding whitespace", () => {
+        expect((0, gitignore_1.hasGitignoreEntry)("node_modules\n" + ENTRY + "\n", ENTRY)).toBe(true);
+        expect((0, gitignore_1.hasGitignoreEntry)("  " + ENTRY + "  \n", ENTRY)).toBe(true);
+    });
+    it("does not match a commented line", () => {
+        expect((0, gitignore_1.hasGitignoreEntry)("# " + ENTRY + "\n", ENTRY)).toBe(false);
+    });
+    it("returns false when absent", () => {
+        expect((0, gitignore_1.hasGitignoreEntry)("node_modules\n", ENTRY)).toBe(false);
+    });
+});
+describe("ensureEntryContent", () => {
+    it("creates content when the file does not exist", () => {
+        const out = (0, gitignore_1.ensureEntryContent)(null, ENTRY);
+        expect(out.changed).toBe(true);
+        expect(out.content).toBe(ENTRY + "\n");
+    });
+    it("appends with a separating newline when the file lacks a trailing one", () => {
+        const out = (0, gitignore_1.ensureEntryContent)("node_modules", ENTRY);
+        expect(out.changed).toBe(true);
+        expect(out.content).toBe("node_modules\n" + ENTRY + "\n");
+    });
+    it("is a no-op when the entry is already present", () => {
+        const existing = "node_modules\n" + ENTRY + "\n";
+        const out = (0, gitignore_1.ensureEntryContent)(existing, ENTRY);
+        expect(out.changed).toBe(false);
+        expect(out.content).toBe(existing);
+    });
+});
+describe("ensureGitignored — I/O", () => {
+    it("creates .gitignore with the entry, then is idempotent", () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), "dove-gitignore-"));
+        const first = (0, gitignore_1.ensureGitignored)(root, ENTRY);
+        expect(first.changed).toBe(true);
+        expect(fs_1.default.readFileSync(path_1.default.join(root, ".gitignore"), "utf8")).toContain(ENTRY);
+        const second = (0, gitignore_1.ensureGitignored)(root, ENTRY);
+        expect(second.changed).toBe(false);
+    });
+});

package/dist/tests/reconcileRecordDiff.test.js

@@ -0,0 +1,125 @@
+"use strict";
+// Tests for the pure reconcile record-diff engine — CRUD classification by
+// sys_id, field-level deltas, and delete disambiguation against the baseline.
+Object.defineProperty(exports, "__esModule", { value: true });
+const recordDiff_1 = require("../reconcile/recordDiff");
+const rec = (over) => ({
+    table: "sys_script_include",
+    scope: "x_cadso_core",
+    name: over.sys_id,
+    updatedOn: "2026-06-01 00:00:00",
+    fields: { "script.js": "var a = 1;" },
+    ...over,
+});
+describe("diffRecords — classification", () => {
+    it("marks a branch-only record as create", () => {
+        const diff = (0, recordDiff_1.diffRecords)({
+            branch: [rec({ sys_id: "a" })],
+            live: [],
+            baselineSysIds: new Set(),
+        });
+        expect(diff.creates.map((c) => c.sys_id)).toEqual(["a"]);
+        expect(diff.updates).toHaveLength(0);
+        expect(diff.deletes).toHaveLength(0);
+    });
+    it("marks identical records as unchanged (not update)", () => {
+        const diff = (0, recordDiff_1.diffRecords)({
+            branch: [rec({ sys_id: "a", fields: { "script.js": "X" } })],
+            live: [rec({ sys_id: "a", fields: { "script.js": "X" } })],
+            baselineSysIds: new Set(["a"]),
+        });
+        expect(diff.unchangedCount).toBe(1);
+        expect(diff.updates).toHaveLength(0);
+        expect(diff.creates).toHaveLength(0);
+        expect(diff.deletes).toHaveLength(0);
+    });
+    it("marks a content difference as update with a changed field delta", () => {
+        const diff = (0, recordDiff_1.diffRecords)({
+            branch: [rec({ sys_id: "a", fields: { "script.js": "NEW" } })],
+            live: [rec({ sys_id: "a", fields: { "script.js": "OLD" } })],
+            baselineSysIds: new Set(["a"]),
+        });
+        expect(diff.updates).toHaveLength(1);
+        const deltas = diff.updates[0].fieldDeltas;
+        expect(deltas).toHaveLength(1);
+        expect(deltas[0]).toMatchObject({
+            field: "script.js",
+            onBranch: true,
+            onLive: true,
+            changed: true,
+        });
+    });
+    it("reports a field present only on the branch and only on the instance", () => {
+        const diff = (0, recordDiff_1.diffRecords)({
+            branch: [rec({ sys_id: "a", fields: { "script.js": "X", "extra.js": "Y" } })],
+            live: [rec({ sys_id: "a", fields: { "script.js": "X", "old.js": "Z" } })],
+            baselineSysIds: new Set(["a"]),
+        });
+        const deltas = diff.updates[0].fieldDeltas;
+        const byField = Object.fromEntries(deltas.map((d) => [d.field, d]));
+        expect(byField["extra.js"]).toMatchObject({ onBranch: true, onLive: false, changed: false });
+        expect(byField["old.js"]).toMatchObject({ onBranch: false, onLive: true, changed: false });
+        // unchanged shared field is not emitted
+        expect(byField["script.js"]).toBeUndefined();
+    });
+});
+describe("diffRecords — delete disambiguation", () => {
+    it("marks an instance-only record in the baseline as a tracked delete", () => {
+        const diff = (0, recordDiff_1.diffRecords)({
+            branch: [],
+            live: [rec({ sys_id: "gone" })],
+            baselineSysIds: new Set(["gone"]),
+        });
+        expect(diff.deletes).toHaveLength(1);
+        expect(diff.deletes[0].deleteDisposition).toBe("tracked");
+    });
+    it("marks an instance-only record absent from the baseline as local-new (drift)", () => {
+        const diff = (0, recordDiff_1.diffRecords)({
+            branch: [],
+            live: [rec({ sys_id: "mine" })],
+            baselineSysIds: new Set(["other"]),
+        });
+        expect(diff.deletes[0].deleteDisposition).toBe("local-new");
+    });
+    it("marks every instance-only record no-baseline when no baseline exists", () => {
+        const diff = (0, recordDiff_1.diffRecords)({
+            branch: [],
+            live: [rec({ sys_id: "x" }), rec({ sys_id: "y" })],
+            baselineSysIds: null,
+        });
+        expect(diff.deletes.map((d) => d.deleteDisposition)).toEqual([
+            "no-baseline",
+            "no-baseline",
+        ]);
+    });
+});
+describe("diffRecords — ordering & convergence", () => {
+    it("sorts each bucket by table then name", () => {
+        const diff = (0, recordDiff_1.diffRecords)({
+            branch: [
+                rec({ sys_id: "2", table: "sys_script", name: "b" }),
+                rec({ sys_id: "1", table: "sys_script", name: "a" }),
+                rec({ sys_id: "3", table: "sys_script_include", name: "a" }),
+            ],
+            live: [],
+            baselineSysIds: new Set(),
+        });
+        expect(diff.creates.map((c) => c.table + "/" + c.name)).toEqual([
+            "sys_script/a",
+            "sys_script/b",
+            "sys_script_include/a",
+        ]);
+    });
+    it("an already-converged instance produces an empty diff (idempotent)", () => {
+        const records = [rec({ sys_id: "a" }), rec({ sys_id: "b" })];
+        const diff = (0, recordDiff_1.diffRecords)({
+            branch: records,
+            live: records,
+            baselineSysIds: new Set(["a", "b"]),
+        });
+        expect(diff.creates).toHaveLength(0);
+        expect(diff.updates).toHaveLength(0);
+        expect(diff.deletes).toHaveLength(0);
+        expect(diff.unchangedCount).toBe(2);
+    });
+});

package/dist/tests/reconcileReport.test.js

@@ -0,0 +1,136 @@
+"use strict";
+// Tests for the pure reconcile report renderer — convergence message, drift
+// banner, instance deep-links, delete partitioning, and the report-only schema
+// section.
+Object.defineProperty(exports, "__esModule", { value: true });
+const report_1 = require("../reconcile/report");
+const emptyDiff = () => ({
+    creates: [],
+    updates: [],
+    deletes: [],
+    unchangedCount: 0,
+});
+const change = (over) => ({
+    table: "sys_script_include",
+    scope: "x_cadso_core",
+    name: over.sys_id,
+    fieldDeltas: [],
+    ...over,
+});
+const scope = (over) => ({
+    scope: "x_cadso_core",
+    diff: emptyDiff(),
+    dirty: [],
+    hasBaseline: true,
+    schema: null,
+    ...over,
+});
+describe("formatReconcileReport", () => {
+    it("reports an in-sync scope and a zeroed summary", () => {
+        const out = (0, report_1.formatReconcileReport)({
+            instanceHost: "tenonworkstudio",
+            branchRef: "main",
+            scopes: [scope({ diff: { ...emptyDiff(), unchangedCount: 12 } })],
+            schemaSkippedReason: null,
+        });
+        expect(out).toContain("in sync (12 records match the instance)");
+        expect(out).toContain("Summary: 0 create, 0 update, 0 delete");
+    });
+    it("renders create/update/delete rows with instance deep links", () => {
+        const diff = {
+            creates: [change({ sys_id: "c1", kind: "create", name: "NewThing" })],
+            updates: [
+                change({
+                    sys_id: "u1",
+                    kind: "update",
+                    name: "Edited",
+                    fieldDeltas: [{ field: "script.js", onBranch: true, onLive: true, changed: true }],
+                }),
+            ],
+            deletes: [change({ sys_id: "d1", kind: "delete", name: "Gone", deleteDisposition: "tracked" })],
+            unchangedCount: 0,
+        };
+        const out = (0, report_1.formatReconcileReport)({
+            instanceHost: "tenonworkstudio",
+            branchRef: "feat/x",
+            scopes: [scope({ diff })],
+            schemaSkippedReason: null,
+        });
+        expect(out).toContain("CREATE (1):");
+        expect(out).toContain("UPDATE (1):");
+        expect(out).toContain("DELETE (1):");
+        expect(out).toContain("https://tenonworkstudio.service-now.com/sys_script_include.do?sys_id=c1");
+        expect(out).toContain("- script.js (changed)");
+        expect(out).toContain("Summary: 1 create, 1 update, 1 delete");
+    });
+    it("keeps local-new instance-only records out of DELETE and never proposes deleting them", () => {
+        const diff = {
+            ...emptyDiff(),
+            deletes: [change({ sys_id: "mine", kind: "delete", name: "DevMade", deleteDisposition: "local-new" })],
+        };
+        const out = (0, report_1.formatReconcileReport)({
+            instanceHost: "tenonworkstudio",
+            branchRef: "main",
+            scopes: [scope({ diff })],
+            schemaSkippedReason: null,
+        });
+        expect(out).toContain("INSTANCE-ONLY");
+        expect(out).not.toContain("DELETE (");
+        expect(out).toContain("Summary: 0 create, 0 update, 0 delete, 1 instance-only kept");
+    });
+    it("surfaces drift and warns that apply would refuse", () => {
+        const out = (0, report_1.formatReconcileReport)({
+            instanceHost: "tenonworkstudio",
+            branchRef: "main",
+            scopes: [
+                scope({
+                    dirty: [
+                        { sys_id: "x", table: "sys_script", name: "Touched", reason: "changed-since-baseline" },
+                    ],
+                }),
+            ],
+            schemaSkippedReason: null,
+        });
+        expect(out).toContain("DRIFT — instance changed since baseline");
+        expect(out).toContain("Apply would REFUSE: 1 record(s) changed on the instance since baseline");
+    });
+    it("warns when no baseline exists for the scope", () => {
+        const out = (0, report_1.formatReconcileReport)({
+            instanceHost: "tenonworkstudio",
+            branchRef: "main",
+            scopes: [scope({ hasBaseline: false })],
+            schemaSkippedReason: null,
+        });
+        expect(out).toContain("no baseline for this instance");
+    });
+    it("renders schema deltas as report-only with dictionary links", () => {
+        const schemaDiff = {
+            instance: "tenonworkstudio",
+            from: { ref: "snap", generated_at: "" },
+            to: { ref: "live", generated_at: "" },
+            scope: "x_cadso_core",
+            summary: { breaking: 1, warn: 0, info: 0 },
+            tables: [],
+            fields: [{ table: "x_cadso_thing", field: "old_col", change: "removed", severity: "BREAKING" }],
+            exit_code: 1,
+        };
+        const out = (0, report_1.formatReconcileReport)({
+            instanceHost: "tenonworkstudio",
+            branchRef: "main",
+            scopes: [scope({ schema: schemaDiff })],
+            schemaSkippedReason: null,
+        });
+        expect(out).toContain("SCHEMA — report-only");
+        expect(out).toContain("removed x_cadso_thing.old_col");
+        expect(out).toContain("sys_dictionary_list.do?sysparm_query=name=x_cadso_thing^element=old_col");
+    });
+    it("notes when the schema arm was skipped", () => {
+        const out = (0, report_1.formatReconcileReport)({
+            instanceHost: "tenonworkstudio",
+            branchRef: "main",
+            scopes: [scope({})],
+            schemaSkippedReason: "no snapshot found",
+        });
+        expect(out).toContain("Schema diff skipped: no snapshot found");
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tenonhq/dovetail-core",
-  "version": "0.0.103",
+  "version": "0.0.105",
   "description": "Next-gen file syncer",
   "license": "GPL-3.0",
   "main": "./dist/index.js",