@tenonhq/dovetail-core 0.0.104 → 0.0.106

package/dist/reconcile/recordSource.js

@@ -0,0 +1,231 @@
+"use strict";
+// I/O adapters that materialize a scope's records into the normalized
+// ReconcileRecord shape, one builder per side:
+//   - loadBranchRecords  reads the on-disk per-scope manifest + each record's
+//     field files (the checked-out branch IS the working tree).
+//   - loadLiveRecords    reads the instance's current record set via the same
+//     getManifest + bulk-download path `dove refresh` uses, but keeps content
+//     in memory instead of writing it to disk.
+// Both strip the metaData bookkeeping file from the comparable field set (see
+// fields.ts), so the pure diff engine sees genuine field content only.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadBranchRecords = loadBranchRecords;
+exports.loadLiveRecords = loadLiveRecords;
+const path_1 = __importDefault(require("path"));
+const fs_1 = require("fs");
+const ConfigManager = __importStar(require("./../config"));
+const snClient_1 = require("./../snClient");
+const appUtils_1 = require("./../appUtils");
+const FileLogger_1 = require("./../FileLogger");
+const fields_1 = require("./fields");
+// Mirror the refresh chunk size so a large scope stays under ServiceNow's ~10 MB
+// REST payload cap.
+const BULK_DOWNLOAD_TABLE_CHUNK_SIZE = 5;
+// Pull `sys_updated_on` out of a metaData.json blob. The instance side carries
+// `sys_updated_on: { value }`; the on-disk side carries the stamped
+// `_lastUpdatedOn`. Either resolves the baseline timestamp; missing -> "".
+function extractUpdatedOn(metaContent) {
+    if (!metaContent) {
+        return "";
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(metaContent);
+    }
+    catch (e) {
+        return "";
+    }
+    if (typeof parsed !== "object" || parsed === null) {
+        return "";
+    }
+    const meta = parsed;
+    const updated = meta.sys_updated_on;
+    if (typeof updated === "object" &&
+        updated !== null &&
+        typeof updated.value === "string") {
+        return updated.value;
+    }
+    if (typeof meta._lastUpdatedOn === "string") {
+        return meta._lastUpdatedOn;
+    }
+    return "";
+}
+function applyWhitelist(manifest, scope) {
+    let allowed = [];
+    try {
+        allowed = ConfigManager.resolveConfigForScope(scope).tables || [];
+    }
+    catch (e) {
+        allowed = [];
+    }
+    if (allowed.length === 0) {
+        return manifest;
+    }
+    const filtered = {};
+    for (const table of Object.keys(manifest.tables || {})) {
+        if (allowed.indexOf(table) !== -1) {
+            filtered[table] = manifest.tables[table];
+        }
+    }
+    return { tables: filtered, scope: manifest.scope };
+}
+// ---------------------------------------------------------------------------
+// Branch side (on-disk)
+// ---------------------------------------------------------------------------
+async function loadBranchRecords(scope) {
+    const manifest = await ConfigManager.loadScopeManifest(scope);
+    if (!manifest || !manifest.tables) {
+        return [];
+    }
+    const whitelisted = applyWhitelist(manifest, scope);
+    const sourcePath = ConfigManager.getSourcePathForScope(scope);
+    const records = [];
+    for (const table of Object.keys(whitelisted.tables)) {
+        const tableRecords = whitelisted.tables[table].records || {};
+        for (const key of Object.keys(tableRecords)) {
+            const meta = tableRecords[key];
+            const folder = (0, appUtils_1.toSafeFolderName)(meta);
+            const recordDir = path_1.default.join(sourcePath, table, folder);
+            const fields = {};
+            let metaContent;
+            for (const file of meta.files || []) {
+                const filePath = path_1.default.join(recordDir, (0, fields_1.fieldKey)(file));
+                let content;
+                try {
+                    content = await fs_1.promises.readFile(filePath, "utf8");
+                }
+                catch (e) {
+                    // A manifest file with no on-disk counterpart (partial checkout): skip
+                    // it rather than fail the whole scope. It simply won't participate in
+                    // the diff for this record.
+                    FileLogger_1.fileLogger.debug("reconcile: missing on-disk field " + filePath);
+                    continue;
+                }
+                if (file.name === "metaData" && file.type === "json") {
+                    metaContent = content;
+                }
+                if ((0, fields_1.isComparableField)(file)) {
+                    fields[(0, fields_1.fieldKey)(file)] = content;
+                }
+            }
+            records.push({
+                table,
+                scope,
+                sys_id: meta.sys_id,
+                name: meta.name || folder,
+                updatedOn: extractUpdatedOn(metaContent),
+                fields,
+            });
+        }
+    }
+    return records;
+}
+// ---------------------------------------------------------------------------
+// Live side (instance)
+// ---------------------------------------------------------------------------
+function buildAllFilesMap(manifest) {
+    const result = {};
+    const tables = manifest.tables || {};
+    for (const table of Object.keys(tables)) {
+        const records = tables[table].records || {};
+        const recMap = {};
+        for (const key of Object.keys(records)) {
+            const rec = records[key];
+            if (!rec.files || rec.files.length === 0) {
+                continue;
+            }
+            recMap[rec.sys_id] = rec.files.map((f) => ({ name: f.name, type: f.type }));
+        }
+        if (Object.keys(recMap).length > 0) {
+            result[table] = recMap;
+        }
+    }
+    return result;
+}
+async function loadLiveRecords(scope) {
+    const client = (0, snClient_1.defaultClient)();
+    const config = ConfigManager.getConfig();
+    const liveManifest = applyWhitelist((0, appUtils_1.normalizeManifestKeys)(await (0, snClient_1.unwrapSNResponse)(client.getManifest(scope, config))), scope);
+    const allFiles = buildAllFilesMap(liveManifest);
+    const tableNames = Object.keys(allFiles);
+    if (tableNames.length === 0) {
+        return [];
+    }
+    // tableOptions feeds field decoding (e.g. JSON fields). Destructure exactly as
+    // the refresh path does so the typed config shape is preserved.
+    const { tableOptions = {} } = config;
+    const downloaded = {};
+    for (let i = 0; i < tableNames.length; i += BULK_DOWNLOAD_TABLE_CHUNK_SIZE) {
+        const chunkTables = tableNames.slice(i, i + BULK_DOWNLOAD_TABLE_CHUNK_SIZE);
+        const chunkMissing = {};
+        for (const t of chunkTables) {
+            chunkMissing[t] = allFiles[t];
+        }
+        const chunkResult = (await (0, snClient_1.unwrapSNResponse)(client.getMissingFiles(chunkMissing, tableOptions)));
+        for (const table of Object.keys(chunkResult)) {
+            downloaded[table] = chunkResult[table];
+        }
+    }
+    const records = [];
+    for (const table of Object.keys(downloaded)) {
+        const tableRecords = downloaded[table].records || {};
+        for (const key of Object.keys(tableRecords)) {
+            const rec = tableRecords[key];
+            const fields = {};
+            let metaContent;
+            for (const file of rec.files || []) {
+                if (file.name === "metaData" && file.type === "json") {
+                    metaContent = file.content;
+                }
+                if ((0, fields_1.isComparableField)(file)) {
+                    fields[(0, fields_1.fieldKey)(file)] = file.content || "";
+                }
+            }
+            records.push({
+                table,
+                scope,
+                sys_id: rec.sys_id,
+                name: rec.name || (0, appUtils_1.toSafeFolderName)(rec),
+                updatedOn: extractUpdatedOn(metaContent),
+                fields,
+            });
+        }
+    }
+    return records;
+}

package/dist/reconcile/report.js

@@ -0,0 +1,193 @@
+"use strict";
+// Pure renderer for the `dove reconcile` dry-run report. Takes the classified
+// diff for every scope plus the optional schema arm and produces a grouped,
+// deep-linked, plain-text report. No I/O, no color codes — so it is exactly
+// assertable in tests and the command layer can print it verbatim.
+//
+// What the report communicates, in priority order:
+//   1. DRIFT (refuse-if-dirty)  — the dev's own instance edits since baseline.
+//      Phase 2 blocks apply on these; Phase 1 surfaces them up top.
+//   2. RECORD DELTAS            — create / update / delete the apply phases act on.
+//   3. SCHEMA DELTAS            — report-only (a ServiceNow ceiling), with the
+//      dictionary deep-links a human needs to apply them by hand.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatReconcileReport = formatReconcileReport;
+function recordLink(host, table, sysId) {
+    if (!host) {
+        return table + ".do?sys_id=" + sysId;
+    }
+    return ("https://" + host + ".service-now.com/" + table + ".do?sys_id=" + sysId);
+}
+function dictionaryLink(host, table, element) {
+    const query = element
+        ? "name=" + table + "^element=" + element
+        : "name=" + table;
+    const base = host ? "https://" + host + ".service-now.com/" : "";
+    return base + "sys_dictionary_list.do?sysparm_query=" + query;
+}
+function recordRow(host, glyph, change) {
+    const label = change.table + " > " + change.name;
+    return "  " + glyph + " " + label + "  " + recordLink(host, change.table, change.sys_id);
+}
+function fieldSubRows(change) {
+    const rows = [];
+    for (const delta of change.fieldDeltas) {
+        let note;
+        if (delta.changed) {
+            note = "changed";
+        }
+        else if (delta.onBranch && !delta.onLive) {
+            note = "missing on instance";
+        }
+        else {
+            note = "extra on instance";
+        }
+        rows.push("      - " + delta.field + " (" + note + ")");
+    }
+    return rows;
+}
+function partitionDeletes(deletes) {
+    const applyable = [];
+    const drift = [];
+    for (const change of deletes) {
+        if (change.deleteDisposition === "tracked") {
+            applyable.push(change);
+        }
+        else {
+            drift.push(change);
+        }
+    }
+    return { applyable, drift };
+}
+function renderScope(host, scopeResult, lines) {
+    const { scope, diff, dirty } = scopeResult;
+    const deletes = partitionDeletes(diff.deletes);
+    lines.push("");
+    lines.push("Scope: " + scope);
+    if (!scopeResult.hasBaseline) {
+        lines.push("  ! no baseline for this instance — deletes are shown but cannot be " +
+            "applied (run a reconcile apply to establish one).");
+    }
+    // 1. Drift first — it is what blocks an apply.
+    if (dirty.length > 0) {
+        lines.push("  DRIFT — instance changed since baseline (apply would refuse):");
+        for (const record of dirty) {
+            lines.push("      ! " +
+                record.table +
+                " > " +
+                record.name +
+                "  " +
+                recordLink(host, record.table, record.sys_id));
+        }
+    }
+    // 2. Record deltas.
+    if (diff.creates.length > 0) {
+        lines.push("  CREATE (" + diff.creates.length + "):");
+        for (const change of diff.creates) {
+            lines.push(recordRow(host, "+", change));
+        }
+    }
+    if (diff.updates.length > 0) {
+        lines.push("  UPDATE (" + diff.updates.length + "):");
+        for (const change of diff.updates) {
+            lines.push(recordRow(host, "~", change));
+            for (const sub of fieldSubRows(change)) {
+                lines.push(sub);
+            }
+        }
+    }
+    if (deletes.applyable.length > 0) {
+        lines.push("  DELETE (" + deletes.applyable.length + "):");
+        for (const change of deletes.applyable) {
+            lines.push(recordRow(host, "-", change));
+        }
+    }
+    if (deletes.drift.length > 0) {
+        lines.push("  INSTANCE-ONLY — present on instance, not in branch, not in baseline " +
+            "(kept, never deleted):");
+        for (const change of deletes.drift) {
+            lines.push(recordRow(host, "?", change));
+        }
+    }
+    // 3. Schema — report-only.
+    renderSchema(host, scopeResult, lines);
+    const noRecordDeltas = diff.creates.length === 0 &&
+        diff.updates.length === 0 &&
+        deletes.applyable.length === 0;
+    if (noRecordDeltas && dirty.length === 0) {
+        lines.push("  in sync (" + diff.unchangedCount + " records match the instance)");
+    }
+}
+function renderSchema(host, scopeResult, lines) {
+    const schema = scopeResult.schema;
+    if (!schema) {
+        return;
+    }
+    const total = schema.summary.breaking + schema.summary.warn + schema.summary.info;
+    if (total === 0) {
+        return;
+    }
+    lines.push("  SCHEMA — report-only (" +
+        total +
+        " change(s); ServiceNow blocks headless dictionary writes — apply by hand):");
+    for (const table of schema.tables) {
+        lines.push("      " +
+            table.change +
+            " table " +
+            table.table +
+            "  " +
+            dictionaryLink(host, table.table, ""));
+    }
+    for (const field of schema.fields) {
+        lines.push("      " +
+            field.change +
+            " " +
+            field.table +
+            "." +
+            field.field +
+            "  " +
+            dictionaryLink(host, field.table, field.field));
+    }
+}
+function formatReconcileReport(input) {
+    const host = input.instanceHost;
+    const lines = [];
+    lines.push("dove reconcile — dry run (no changes applied)");
+    lines.push("  instance  " + (host || "(unknown)"));
+    lines.push("  branch    " + (input.branchRef || "(unknown)"));
+    let totalCreates = 0;
+    let totalUpdates = 0;
+    let totalDeletes = 0;
+    let totalDrift = 0;
+    let totalInstanceOnly = 0;
+    for (const scopeResult of input.scopes) {
+        renderScope(host, scopeResult, lines);
+        const deletes = partitionDeletes(scopeResult.diff.deletes);
+        totalCreates += scopeResult.diff.creates.length;
+        totalUpdates += scopeResult.diff.updates.length;
+        totalDeletes += deletes.applyable.length;
+        totalInstanceOnly += deletes.drift.length;
+        totalDrift += scopeResult.dirty.length;
+    }
+    if (input.schemaSkippedReason) {
+        lines.push("");
+        lines.push("Schema diff skipped: " + input.schemaSkippedReason);
+    }
+    lines.push("");
+    lines.push("Summary: " +
+        totalCreates +
+        " create, " +
+        totalUpdates +
+        " update, " +
+        totalDeletes +
+        " delete" +
+        (totalInstanceOnly > 0 ? ", " + totalInstanceOnly + " instance-only kept" : "") +
+        (totalDrift > 0 ? ", " + totalDrift + " drift" : ""));
+    if (totalDrift > 0) {
+        lines.push("Apply would REFUSE: " +
+            totalDrift +
+            " record(s) changed on the instance since baseline. " +
+            "Keep them with a refresh, or discard with --force.");
+    }
+    return lines.join("\n");
+}

package/dist/reconcile/types.js

@@ -0,0 +1,6 @@
+"use strict";
+// Domain types for `dove reconcile` — the deliberate inverse of `dove watch`:
+// make a developer's personal ServiceNow instance match the git branch they
+// just checked out. Phase 1 is read-only (diff + report); these types are
+// shared by the apply phases (2 + 3) as they land.
+Object.defineProperty(exports, "__esModule", { value: true });