@tenonhq/dovetail-core 0.0.124 → 0.0.125

package/dist/pullRecordCommand.js

@@ -0,0 +1,161 @@
+"use strict";
+/**
+ * `dove pull <table> <sysId...>` — the per-record form of pull. See
+ * pullRecord.ts for the engine; this file is the CLI surface: argument
+ * normalization, the dry-run report, and the summary.
+ *
+ * A bare `dove pull` (no table, no --from-update-set) is still the historic
+ * alias of `dove refresh`; commander.ts routes that case before reaching here.
+ */
+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.collectTargets = collectTargets;
+exports.pullRecordCommand = pullRecordCommand;
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const Logger_1 = require("./Logger");
+const FileLogger_1 = require("./FileLogger");
+const commands_1 = require("./commands");
+const ConfigManager = __importStar(require("./config"));
+const pullRecord_1 = require("./pullRecord");
+function relToRoot(p) {
+    try {
+        return path_1.default.relative(ConfigManager.getRootDir(), p) || ".";
+    }
+    catch (e) {
+        return p;
+    }
+}
+function describeRecord(rec, dryRun) {
+    const lines = [];
+    const verb = dryRun ? "would write" : "wrote";
+    lines.push(chalk_1.default.bold(rec.table) + " " + rec.sysId + "  →  " + chalk_1.default.cyan(relToRoot(rec.recordDir) + path_1.default.sep) +
+        chalk_1.default.dim("  [" + rec.scope + "]"));
+    for (const f of rec.files) {
+        const mark = f.action === "write" ? chalk_1.default.green("+") : chalk_1.default.dim("=");
+        const note = f.action === "write" ? verb : "unchanged";
+        lines.push("  " + mark + " " + path_1.default.basename(f.path) + chalk_1.default.dim("  (" + note + ")"));
+    }
+    const manifestNote = rec.manifestAction === "add" ? "add" : rec.manifestAction === "update" ? "update" : "unchanged";
+    lines.push("  " + (rec.manifestAction === "unchanged" ? chalk_1.default.dim("=") : chalk_1.default.green("~")) +
+        " manifest key " + JSON.stringify(rec.key) + chalk_1.default.dim("  (" + manifestNote + ")"));
+    for (const w of rec.warnings)
+        lines.push("  " + chalk_1.default.yellow("!") + " " + w);
+    return lines;
+}
+function report(plan, dryRun) {
+    for (const rec of plan.records) {
+        for (const line of describeRecord(rec, dryRun))
+            Logger_1.logger.info(line);
+    }
+    for (const m of plan.manifests) {
+        const touched = m.records.filter((r) => r.manifestAction !== "unchanged").length;
+        if (touched === 0)
+            continue;
+        Logger_1.logger.info((dryRun ? "would splice " : "spliced ") + touched + " entr" + (touched === 1 ? "y" : "ies") +
+            " into " + chalk_1.default.cyan(relToRoot(m.manifestPath)) + (m.existed ? "" : chalk_1.default.dim("  (new file)")));
+    }
+    for (const w of plan.warnings)
+        Logger_1.logger.warn(w);
+}
+/**
+ * Turn the CLI arguments into pull targets. Positional sys_ids and `--sys-ids`
+ * compose; `--from-update-set` expands to the set's per-record captures (and
+ * composes with an explicit table + sys_ids too).
+ */
+async function collectTargets(args) {
+    const targets = [];
+    let skipped = [];
+    const ids = (0, pullRecord_1.normalizeSysIds)([]
+        .concat(Array.isArray(args.sysId) ? args.sysId : [args.sysId])
+        .concat(Array.isArray(args.sysIds) ? args.sysIds : [args.sysIds])
+        .concat(Array.isArray(args["sys-ids"]) ? args["sys-ids"] : [args["sys-ids"]]));
+    if (args.table) {
+        const table = (0, pullRecord_1.assertTableName)(args.table);
+        if (ids.length === 0 && !args.fromUpdateSet) {
+            throw new Error("dove pull " + table + ": give at least one sys_id (positional, or --sys-ids a,b,c), " +
+                "or use --from-update-set <sys_id>. A bare 'dove pull' is the scope-wide refresh.");
+        }
+        for (const sysId of ids)
+            targets.push({ table, sysId });
+    }
+    else if (ids.length > 0) {
+        throw new Error("dove pull: a table name is required before the sys_id(s).");
+    }
+    if (args.fromUpdateSet) {
+        const fromSet = await (0, pullRecord_1.targetsFromUpdateSet)(String(args.fromUpdateSet));
+        for (const t of fromSet.targets)
+            targets.push(t);
+        skipped = fromSet.skipped;
+    }
+    return { targets, skipped };
+}
+async function pullRecordCommand(args) {
+    (0, commands_1.setLogLevel)(args);
+    try {
+        if (args.t !== undefined && !args.table) {
+            throw new Error("dove pull has no -t/--table flag. For a table-narrowed scope refresh use " +
+                "'dove refresh -t <table>'; for one record use 'dove pull <table> <sys_id>'.");
+        }
+        const dryRun = !!args.dryRun;
+        const { targets, skipped } = await collectTargets(args);
+        for (const s of skipped)
+            Logger_1.logger.warn("skipped " + s);
+        if (targets.length === 0) {
+            throw new Error("Nothing to pull: no per-record targets resolved.");
+        }
+        FileLogger_1.fileLogger.debug("pull: " + targets.length + " target(s), scope=" + (args.scope || "auto") +
+            ", force=" + !!args.force + ", dryRun=" + dryRun);
+        const plan = await (0, pullRecord_1.planPull)(targets, { scope: args.scope, force: !!args.force });
+        if (dryRun) {
+            Logger_1.logger.info(chalk_1.default.bold("Dry run — nothing written."));
+            report(plan, true);
+            return;
+        }
+        const result = await (0, pullRecord_1.applyPull)(plan);
+        report(plan, false);
+        Logger_1.logger.success("Pulled " + plan.records.length + " record(s): " + result.filesWritten + " file(s) written, " +
+            result.filesUnchanged + " unchanged, " + result.manifestsWritten.length + " manifest(s) updated.");
+    }
+    catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        Logger_1.logger.error(message);
+        FileLogger_1.fileLogger.error("pull failed: " + message);
+        process.exitCode = 1;
+    }
+}

package/dist/snClient.js

@@ -366,6 +366,37 @@ const snClient = (baseURL, username, password, apiKey) => {
             },
         });
     };
+    /**
+     * Reads ONE record by sys_id, selecting only its class and owning scope, so a
+     * per-record pull can resolve (and refuse) the target scope before it fetches
+     * any content. Plain Table API read — no Dovetail server op involved.
+     */
+    const getRecordScope = (table, sysId) => {
+        const endpoint = "api/now/table/" + encodeURIComponent(table) + "/" + encodeURIComponent(sysId);
+        return client.get(endpoint, {
+            params: {
+                sysparm_fields: "sys_id,sys_class_name,sys_scope,sys_scope.scope",
+                sysparm_display_value: "false",
+            },
+        });
+    };
+    /**
+     * One page of a update set's customer updates (`sys_update_xml`), ordered by
+     * name so paging is stable. The caller pages with offset/limit; the instance
+     * caps a single page at 1000 rows.
+     */
+    const getUpdateSetMembers = (updateSetSysId, offset, limit) => {
+        const endpoint = "api/now/table/sys_update_xml";
+        return client.get(endpoint, {
+            params: {
+                sysparm_query: "update_set=" + updateSetSysId + "^ORDERBYname",
+                sysparm_fields: "sys_id,name,action,target_name,type",
+                sysparm_display_value: "false",
+                sysparm_limit: limit,
+                sysparm_offset: offset,
+            },
+        });
+    };
     const getUserSysId = (userName = process.env.SN_USER) => {
         const endpoint = "api/now/table/sys_user";
         return client.get(endpoint, {
@@ -538,6 +569,8 @@ const snClient = (baseURL, username, password, apiKey) => {
         getScopeId,
         getScopeById,
         getUpdateSetById,
+        getRecordScope,
+        getUpdateSetMembers,
         getUserSysId,
         getCurrentAppUserPrefSysId,
         updateCurrentAppUserPref,

package/dist/tests/commanderStrict.test.js

@@ -39,6 +39,7 @@ jest.mock("../schemaCommand", () => ({
 jest.mock("../claudeCommand", () => ({ initClaudeCommand: jest.fn() }));
 jest.mock("../createRecordCommand", () => ({ createRecordCommand: jest.fn() }));
 jest.mock("../deleteRecordCommand", () => ({ deleteRecordCommand: jest.fn() }));
+jest.mock("../pullRecordCommand", () => ({ pullRecordCommand: jest.fn() }));
 jest.mock("../reconcileCommand", () => ({ reconcileCommand: jest.fn() }));
 jest.mock("../migrateCommand", () => ({ migrateCommand: jest.fn() }));
 jest.mock("../loginCommand", () => ({ loginCommand: jest.fn() }));
@@ -58,6 +59,7 @@ jest.mock("../clickupCommands", () => ({
 const yargs_1 = __importDefault(require("yargs/yargs"));
 const commander_1 = require("../commander");
 const commands_1 = require("../commands");
+const pullRecordCommand_1 = require("../pullRecordCommand");
 /**
  * @description Runs a fake `dove` invocation through a fresh, non-exiting parser.
  * @param {string[]} args - Argv as the user would type it, minus the binary name.
@@ -101,6 +103,45 @@ describe("dove pull", function () {
         expect(argv.scope).toBe("x_cadso_core");
         expect(argv.force).toBe(true);
         expect(commands_1.refreshCommand).toHaveBeenCalledTimes(1);
+        expect(pullRecordCommand_1.pullRecordCommand).not.toHaveBeenCalled();
+    });
+    it("re-maps a bare `pull -t <table>` to refresh --table (the old spelling keeps working)", async function () {
+        const { error } = await run(["pull", "-t", "sys_script_include", "--metadata-only"]);
+        expect(error).toBeUndefined();
+        expect(commands_1.refreshCommand).toHaveBeenCalledTimes(1);
+        const passed = commands_1.refreshCommand.mock.calls[0][0];
+        expect(passed.table).toBe("sys_script_include");
+        expect(passed.metadataOnly).toBe(true);
+        expect(pullRecordCommand_1.pullRecordCommand).not.toHaveBeenCalled();
+    });
+    it("routes `pull <table> <sysId...>` to the per-record pull, not refresh", async function () {
+        const { error, argv } = await run([
+            "pull", "sys_security_acl", "94243ee5c3f78f10d4ddf1db050131a6", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1",
+            "--scope", "x_cadso_journey", "--dry-run",
+        ]);
+        expect(error).toBeUndefined();
+        expect(argv.table).toBe("sys_security_acl");
+        expect(argv.sysId).toEqual(["94243ee5c3f78f10d4ddf1db050131a6", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1"]);
+        expect(argv.dryRun).toBe(true);
+        expect(pullRecordCommand_1.pullRecordCommand).toHaveBeenCalledTimes(1);
+        expect(commands_1.refreshCommand).not.toHaveBeenCalled();
+    });
+    it("keeps --sys-ids distinct from the positional list", async function () {
+        const { error, argv } = await run([
+            "pull", "sys_security_acl", "94243ee5c3f78f10d4ddf1db050131a6",
+            "--sys-ids", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1,bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb2",
+        ]);
+        expect(error).toBeUndefined();
+        expect(argv.sysId).toEqual(["94243ee5c3f78f10d4ddf1db050131a6"]);
+        expect(argv.sysIds).toBe("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1,bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb2");
+        expect(pullRecordCommand_1.pullRecordCommand).toHaveBeenCalledTimes(1);
+    });
+    it("routes `pull --from-update-set` (no table) to the per-record pull", async function () {
+        const { error, argv } = await run(["pull", "--from-update-set", "dddddddddddddddddddddddddddddddd"]);
+        expect(error).toBeUndefined();
+        expect(argv.fromUpdateSet).toBe("dddddddddddddddddddddddddddddddd");
+        expect(pullRecordCommand_1.pullRecordCommand).toHaveBeenCalledTimes(1);
+        expect(commands_1.refreshCommand).not.toHaveBeenCalled();
     });
 });
 describe("unknown commands", function () {