@tenonhq/dovetail-core 0.0.85

package/dist/tests/pushFiles.test.js

@@ -0,0 +1,248 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Track how many times the update set config file is read
+var configReadCount = 0;
+var mockConfigData = {};
+// Per-scope read-only table sets, consumed by the mocked ../config module.
+// Mutate this object between tests to drive the push-gate behavior.
+var mockReadOnlyByScope = {};
+jest.mock("fs", function () {
+    var actualFs = jest.requireActual("fs");
+    return {
+        ...actualFs,
+        existsSync: function (p) {
+            if (typeof p === "string" && p.endsWith(".dove-update-sets.json")) {
+                configReadCount++;
+                return Object.keys(mockConfigData).length > 0;
+            }
+            return actualFs.existsSync(p);
+        },
+        readFileSync: function (p, encoding) {
+            if (typeof p === "string" && p.endsWith(".dove-update-sets.json")) {
+                return JSON.stringify(mockConfigData);
+            }
+            return actualFs.readFileSync(p, encoding);
+        },
+    };
+});
+// Mock only the config surface pushFiles touches. getReadOnlyTablesForScope
+// is the one new call site; the rest of pushFiles reads no ConfigManager
+// exports, so a minimal mock keeps the test focused on the push gate.
+jest.mock("../config", function () {
+    return {
+        getReadOnlyTablesForScope: function (scope) {
+            return mockReadOnlyByScope[scope] || new Set();
+        },
+    };
+});
+// Mock dependencies that pushFiles needs
+var mockPushWithUpdateSet = jest.fn().mockResolvedValue({
+    data: { result: { status: "success" } },
+});
+var mockUpdateRecord = jest.fn().mockResolvedValue({
+    data: { result: { status: "success" } },
+});
+jest.mock("../snClient", function () {
+    return {
+        defaultClient: function () {
+            return {
+                pushWithUpdateSet: mockPushWithUpdateSet,
+                updateRecord: mockUpdateRecord,
+            };
+        },
+        processPushResponse: function (_res, summary) {
+            return { success: true, message: summary };
+        },
+        retryOnErr: function (fn) {
+            return fn();
+        },
+        retryOnHttpErr: function (fn) {
+            return fn();
+        },
+        unwrapSNResponse: jest.fn(),
+        unwrapTableAPIFirstItem: jest.fn(),
+        SNClient: jest.fn(),
+    };
+});
+jest.mock("../PluginManager", function () {
+    return {
+        __esModule: true,
+        default: {
+            getFinalFileContents: function (ctx) {
+                return Promise.resolve("built-content");
+            },
+        },
+    };
+});
+jest.mock("../Logger", function () {
+    return {
+        logger: {
+            info: jest.fn(),
+            debug: jest.fn(),
+            warn: jest.fn(),
+            error: jest.fn(),
+            getLogLevel: function () { return "debug"; },
+        },
+    };
+});
+jest.mock("progress", function () {
+    return jest.fn().mockImplementation(function () {
+        return { tick: jest.fn() };
+    });
+});
+function makeRecord(table, sysId, scope) {
+    return {
+        table: table,
+        sysId: sysId,
+        fields: {
+            script: {
+                name: "TestRecord",
+                tableName: table,
+                targetField: "script",
+                ext: "js",
+                sys_id: sysId,
+                filePath: "/fake/path/script.js",
+                scope: scope,
+            },
+        },
+    };
+}
+describe("pushFiles", function () {
+    beforeEach(function () {
+        configReadCount = 0;
+        mockConfigData = {};
+        mockReadOnlyByScope = {};
+        mockPushWithUpdateSet.mockClear();
+        mockUpdateRecord.mockClear();
+    });
+    it("reads update set config once at batch start, not per record", async function () {
+        // Set up config for two scopes
+        mockConfigData = {
+            "x_cadso_core": { sys_id: "us-core-123", name: "Core US" },
+            "x_cadso_work": { sys_id: "us-work-456", name: "Work US" },
+        };
+        var { pushFiles } = require("../appUtils");
+        var records = [
+            makeRecord("sys_script_include", "rec1", "x_cadso_core"),
+            makeRecord("sys_script_include", "rec2", "x_cadso_work"),
+            makeRecord("sys_script_include", "rec3", "x_cadso_core"),
+        ];
+        await pushFiles(records);
+        // Config existsSync is hit twice at batch start: once by resolveDoveDotfile
+        // (preferring .dove-update-sets.json over the legacy .sinc-* fallback) and
+        // once by getUpdateSetConfig() to gate the JSON read. The point of this
+        // test is that the count is bounded by the resolution + read pattern, not
+        // by record count — 3 records still produces 2 checks, not 6.
+        expect(configReadCount).toBe(2);
+    });
+    it("does not re-read config mid-batch even with multiple scopes", async function () {
+        mockConfigData = {
+            "x_cadso_core": { sys_id: "us-core-123", name: "Core US" },
+        };
+        var { pushFiles } = require("../appUtils");
+        var records = [
+            makeRecord("sys_script_include", "rec1", "x_cadso_core"),
+            makeRecord("sys_script_include", "rec2", "x_cadso_core"),
+        ];
+        await pushFiles(records);
+        // Bounded by resolver + read-gate (see note above), not by record count.
+        expect(configReadCount).toBe(2);
+    });
+    it("routes records to correct update sets from cached config", async function () {
+        mockConfigData = {
+            "x_cadso_core": { sys_id: "us-core-123", name: "Core US" },
+            "x_cadso_work": { sys_id: "us-work-456", name: "Work US" },
+        };
+        var { pushFiles } = require("../appUtils");
+        var records = [
+            makeRecord("sys_script_include", "rec1", "x_cadso_core"),
+            makeRecord("sys_script_include", "rec2", "x_cadso_work"),
+        ];
+        await pushFiles(records);
+        // Both should use pushWithUpdateSet with their respective update set IDs
+        expect(mockPushWithUpdateSet).toHaveBeenCalledTimes(2);
+        var calls = mockPushWithUpdateSet.mock.calls;
+        var updateSetIds = calls.map(function (call) { return call[0]; });
+        expect(updateSetIds).toContain("us-core-123");
+        expect(updateSetIds).toContain("us-work-456");
+    });
+    it("uses updateRecord when no update set config exists", async function () {
+        mockConfigData = {};
+        var { pushFiles } = require("../appUtils");
+        var records = [
+            makeRecord("sys_script_include", "rec1", "x_cadso_core"),
+        ];
+        await pushFiles(records);
+        expect(mockUpdateRecord).toHaveBeenCalledTimes(1);
+        expect(mockPushWithUpdateSet).not.toHaveBeenCalled();
+    });
+    it("skips push for tables listed in _readOnlyTables for the scope", async function () {
+        mockConfigData = {};
+        mockReadOnlyByScope = {
+            x_cadso_core: new Set(["sys_hub_flow"]),
+        };
+        var { pushFiles } = require("../appUtils");
+        var records = [
+            makeRecord("sys_hub_flow", "flow1", "x_cadso_core"),
+        ];
+        var results = await pushFiles(records);
+        expect(mockPushWithUpdateSet).not.toHaveBeenCalled();
+        expect(mockUpdateRecord).not.toHaveBeenCalled();
+        expect(results).toHaveLength(1);
+        expect(results[0].success).toBe(true);
+        expect(results[0].message).toContain("skipped (read-only table)");
+    });
+    it("pushes normally when the scope has no read-only tables", async function () {
+        mockConfigData = {};
+        mockReadOnlyByScope = {};
+        var { pushFiles } = require("../appUtils");
+        var records = [
+            makeRecord("sys_script_include", "rec1", "x_cadso_core"),
+        ];
+        await pushFiles(records);
+        expect(mockUpdateRecord).toHaveBeenCalledTimes(1);
+        expect(mockPushWithUpdateSet).not.toHaveBeenCalled();
+    });
+    it("in a mixed batch, only non-read-only tables are pushed", async function () {
+        mockConfigData = {};
+        mockReadOnlyByScope = {
+            x_cadso_core: new Set(["sys_hub_flow"]),
+        };
+        var { pushFiles } = require("../appUtils");
+        var records = [
+            makeRecord("sys_hub_flow", "flow1", "x_cadso_core"),
+            makeRecord("sys_script_include", "rec1", "x_cadso_core"),
+            makeRecord("sys_hub_action_instance", "ai1", "x_cadso_core"),
+        ];
+        var results = await pushFiles(records);
+        // Only the read-only flow row is skipped; the other two hit updateRecord.
+        expect(mockUpdateRecord).toHaveBeenCalledTimes(2);
+        expect(mockPushWithUpdateSet).not.toHaveBeenCalled();
+        expect(results).toHaveLength(3);
+        var skipped = results.filter(function (r) {
+            return r.message.indexOf("skipped (read-only table)") !== -1;
+        });
+        expect(skipped).toHaveLength(1);
+    });
+    it("applies scope-specific read-only tables independently across scopes", async function () {
+        mockConfigData = {};
+        mockReadOnlyByScope = {
+            x_cadso_core: new Set(["sys_hub_flow"]),
+            x_cadso_work: new Set(),
+        };
+        var { pushFiles } = require("../appUtils");
+        var records = [
+            makeRecord("sys_hub_flow", "flow1", "x_cadso_core"),
+            makeRecord("sys_hub_flow", "flow2", "x_cadso_work"),
+        ];
+        var results = await pushFiles(records);
+        // x_cadso_core's flow is blocked; x_cadso_work's flow pushes because it
+        // isn't in that scope's read-only set.
+        expect(mockUpdateRecord).toHaveBeenCalledTimes(1);
+        expect(results).toHaveLength(2);
+        var skipped = results.filter(function (r) {
+            return r.message.indexOf("skipped (read-only table)") !== -1;
+        });
+        expect(skipped).toHaveLength(1);
+    });
+});

package/dist/tests/rateLimitCoordination.test.js

@@ -0,0 +1,271 @@
+"use strict";
+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 });
+function createMockWatcher() {
+    var handlers = {};
+    var mock = {
+        _handlers: handlers,
+        on: jest.fn(function (event, handler) {
+            if (!handlers[event])
+                handlers[event] = [];
+            handlers[event].push(handler);
+            return mock;
+        }),
+        close: jest.fn(),
+        _emit: function (event) {
+            var args = Array.prototype.slice.call(arguments, 1);
+            (handlers[event] || []).forEach(function (h) { h.apply(null, args); });
+        },
+    };
+    return mock;
+}
+var mockWatchers = [];
+jest.mock("chokidar", function () {
+    return {
+        watch: jest.fn(function () {
+            var w = createMockWatcher();
+            mockWatchers.push(w);
+            return w;
+        }),
+    };
+});
+jest.mock("lodash", function () {
+    var actual = jest.requireActual("lodash");
+    return {
+        ...actual,
+        debounce: jest.fn(function (fn) {
+            var wrapper = jest.fn();
+            wrapper.cancel = jest.fn();
+            wrapper.flush = jest.fn(function () { return fn(); });
+            return wrapper;
+        }),
+    };
+});
+var mockSNClient = {
+    getScopeId: jest.fn(),
+    getUserSysId: jest.fn(),
+    getCurrentAppUserPrefSysId: jest.fn(),
+    updateCurrentAppUserPref: jest.fn(),
+    createCurrentAppUserPref: jest.fn(),
+    getCurrentUpdateSetUserPref: jest.fn(),
+};
+jest.mock("../snClient", function () {
+    return {
+        defaultClient: jest.fn(function () { return mockSNClient; }),
+        unwrapSNResponse: jest.fn(function (val) { return val; }),
+    };
+});
+jest.mock("../FileUtils", function () {
+    return {
+        getFileContextFromPath: jest.fn(),
+        getFileContextWithSkipReason: jest.fn(),
+    };
+});
+jest.mock("../appUtils", function () {
+    return {
+        groupAppFiles: jest.fn(),
+        pushFiles: jest.fn(),
+    };
+});
+jest.mock("../logMessages", function () {
+    return { logFilePush: jest.fn() };
+});
+jest.mock("../recentEdits", function () {
+    return { writeRecentEdit: jest.fn() };
+});
+jest.mock("../Logger", function () {
+    return {
+        logger: {
+            info: jest.fn(),
+            error: jest.fn(),
+            warn: jest.fn(),
+            debug: jest.fn(),
+            success: jest.fn(),
+            getLogLevel: jest.fn().mockReturnValue("info"),
+        },
+    };
+});
+jest.mock("../config", function () {
+    return {
+        loadConfigs: jest.fn().mockResolvedValue(undefined),
+        getConfig: jest.fn(),
+        getRootDir: jest.fn().mockReturnValue("/project"),
+        updateManifest: jest.fn(),
+        getManifest: jest.fn(),
+        getSourcePath: jest.fn().mockReturnValue("/project/src"),
+        getScopeManifestPath: jest.fn(function (scope) { return "/project/dove.manifest." + scope + ".json"; }),
+        getManifestPath: jest.fn().mockReturnValue("/project/dove.manifest.json"),
+    };
+});
+jest.mock("fs", function () {
+    return {
+        existsSync: jest.fn(),
+        readFileSync: jest.fn(),
+        writeFileSync: jest.fn(),
+        promises: {
+            readFile: jest.fn(),
+            writeFile: jest.fn(),
+            readdir: jest.fn(),
+            mkdir: jest.fn(),
+            access: jest.fn(),
+            stat: jest.fn(),
+        },
+    };
+});
+jest.mock("axios", function () {
+    return {
+        default: {
+            create: jest.fn(function () {
+                return { get: jest.fn().mockResolvedValue({ data: { result: null } }) };
+            }),
+        },
+    };
+});
+// --- Imports ---
+const ConfigManager = __importStar(require("../config"));
+const Logger_1 = require("../Logger");
+const MultiScopeWatcher_1 = require("../MultiScopeWatcher");
+const fs_1 = __importDefault(require("fs"));
+var MOCK_CONFIG = {
+    sourceDirectory: "src",
+    buildDirectory: "build",
+    rules: [],
+    includes: {},
+    excludes: {},
+    tableOptions: {},
+    refreshInterval: 30,
+    scopes: {
+        x_test_core: { sourceDirectory: "src/x_test_core" },
+        x_test_work: {},
+    },
+};
+describe("US-009: Rate limit coordination", function () {
+    beforeEach(function () {
+        jest.clearAllMocks();
+        mockWatchers.length = 0;
+        (0, MultiScopeWatcher_1.stopMultiScopeWatching)();
+        mockSNClient.getScopeId.mockResolvedValue([{ sys_id: "scope_sys_id" }]);
+        mockSNClient.getUserSysId.mockResolvedValue([{ sys_id: "user_sys_id" }]);
+        mockSNClient.getCurrentAppUserPrefSysId.mockResolvedValue([{ sys_id: "pref_sys_id" }]);
+        mockSNClient.updateCurrentAppUserPref.mockResolvedValue({});
+        mockSNClient.getCurrentUpdateSetUserPref.mockResolvedValue([]);
+    });
+    afterEach(function () {
+        (0, MultiScopeWatcher_1.stopMultiScopeWatching)();
+    });
+    describe("configurable monitoring interval", function () {
+        it("uses the provided monitorIntervalMs", async function () {
+            var setIntervalSpy = jest.spyOn(global, "setInterval");
+            ConfigManager.getConfig.mockReturnValue({
+                ...MOCK_CONFIG,
+                scopes: { x_test: {} },
+            });
+            await (0, MultiScopeWatcher_1.startMultiScopeWatching)({ monitorIntervalMs: 60000 });
+            await new Promise(function (r) { setTimeout(r, 50); });
+            expect(setIntervalSpy).toHaveBeenCalledWith(expect.any(Function), 60000);
+            setIntervalSpy.mockRestore();
+        });
+        it("defaults to 120s when no options provided", async function () {
+            var setIntervalSpy = jest.spyOn(global, "setInterval");
+            ConfigManager.getConfig.mockReturnValue({
+                ...MOCK_CONFIG,
+                scopes: { x_test: {} },
+            });
+            await (0, MultiScopeWatcher_1.startMultiScopeWatching)();
+            await new Promise(function (r) { setTimeout(r, 50); });
+            expect(setIntervalSpy).toHaveBeenCalledWith(expect.any(Function), 120000);
+            setIntervalSpy.mockRestore();
+        });
+        it("disables monitoring when monitorIntervalMs is 0", async function () {
+            var setIntervalSpy = jest.spyOn(global, "setInterval");
+            ConfigManager.getConfig.mockReturnValue({
+                ...MOCK_CONFIG,
+                scopes: { x_test: {} },
+            });
+            await (0, MultiScopeWatcher_1.startMultiScopeWatching)({ monitorIntervalMs: 0 });
+            await new Promise(function (r) { setTimeout(r, 50); });
+            expect(setIntervalSpy).not.toHaveBeenCalled();
+            expect(Logger_1.logger.info).toHaveBeenCalledWith(expect.stringContaining("monitoring disabled"));
+            setIntervalSpy.mockRestore();
+        });
+    });
+    describe("monitoring uses local config (no API calls)", function () {
+        it("reads update set config from local file instead of making API calls", async function () {
+            ConfigManager.getConfig.mockReturnValue({
+                ...MOCK_CONFIG,
+                scopes: { x_scope_a: {}, x_scope_b: {} },
+            });
+            // Simulate update set config on disk
+            fs_1.default.existsSync.mockReturnValue(true);
+            fs_1.default.readFileSync.mockReturnValue(JSON.stringify({
+                x_scope_a: { sys_id: "us_a", name: "Task A Update Set" },
+                x_scope_b: { sys_id: "us_b", name: "Task B Update Set" },
+            }));
+            await (0, MultiScopeWatcher_1.startMultiScopeWatching)({ monitorIntervalMs: 60000 });
+            await new Promise(function (r) { setTimeout(r, 50); });
+            // Monitoring should NOT call any SN API (getScopeId is only from startWatching scope switching)
+            // The checkAllUpdateSets method uses local config file — no getUserSysId, no getCurrentUpdateSetUserPref
+            expect(Logger_1.logger.info).toHaveBeenCalledWith(expect.stringContaining("Task A Update Set"));
+            expect(Logger_1.logger.info).toHaveBeenCalledWith(expect.stringContaining("Task B Update Set"));
+        });
+        it("warns when scope has no update set configured", async function () {
+            ConfigManager.getConfig.mockReturnValue({
+                ...MOCK_CONFIG,
+                scopes: { x_scope_a: {} },
+            });
+            fs_1.default.existsSync.mockReturnValue(true);
+            fs_1.default.readFileSync.mockReturnValue(JSON.stringify({}));
+            await (0, MultiScopeWatcher_1.startMultiScopeWatching)({ monitorIntervalMs: 60000 });
+            await new Promise(function (r) { setTimeout(r, 50); });
+            expect(Logger_1.logger.warn).toHaveBeenCalledWith(expect.stringContaining("No update set configured"));
+        });
+        it("warns when scope is on Default update set", async function () {
+            ConfigManager.getConfig.mockReturnValue({
+                ...MOCK_CONFIG,
+                scopes: { x_scope_a: {} },
+            });
+            fs_1.default.existsSync.mockReturnValue(true);
+            fs_1.default.readFileSync.mockReturnValue(JSON.stringify({
+                x_scope_a: { sys_id: "us_default", name: "Default" },
+            }));
+            await (0, MultiScopeWatcher_1.startMultiScopeWatching)({ monitorIntervalMs: 60000 });
+            await new Promise(function (r) { setTimeout(r, 50); });
+            expect(Logger_1.logger.warn).toHaveBeenCalledWith(expect.stringContaining("DEFAULT update set"));
+        });
+    });
+});

package/dist/tests/resolveConfigReadOnly.test.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = require("../config");
+const baseConfig = {
+    sourceDirectory: "src",
+    buildDirectory: "build",
+    includes: {},
+    excludes: {},
+    tableOptions: {},
+    refreshInterval: 30,
+    scopes: {},
+};
+function withIncludes(overrides) {
+    return {
+        ...baseConfig,
+        includes: overrides,
+    };
+}
+describe("resolveConfigForScope - _readOnlyTables", () => {
+    it("returns an empty list when _readOnlyTables is absent", () => {
+        const cfg = withIncludes({ _tables: ["incident", "sys_hub_flow"] });
+        const resolved = (0, config_1.resolveConfigForScope)("any_scope", cfg);
+        expect(resolved.readOnlyTables).toEqual([]);
+    });
+    it("returns the global _readOnlyTables list when no scope override", () => {
+        const cfg = withIncludes({
+            _tables: ["incident", "sys_hub_flow"],
+            _readOnlyTables: ["sys_hub_flow"],
+        });
+        const resolved = (0, config_1.resolveConfigForScope)("x_cadso_core", cfg);
+        expect(resolved.readOnlyTables).toEqual(["sys_hub_flow"]);
+    });
+    it("unions global and scope _readOnlyTables without duplicates", () => {
+        const cfg = withIncludes({
+            _tables: ["incident", "sys_hub_flow", "sys_hub_action_instance"],
+            _readOnlyTables: ["sys_hub_flow"],
+            _scopes: {
+                x_cadso_core: {
+                    _readOnlyTables: ["sys_hub_flow", "sys_hub_action_instance"],
+                },
+            },
+        });
+        const resolved = (0, config_1.resolveConfigForScope)("x_cadso_core", cfg);
+        expect(resolved.readOnlyTables.sort()).toEqual(["sys_hub_action_instance", "sys_hub_flow"].sort());
+    });
+    it("falls back to the global list for scopes without an override", () => {
+        const cfg = withIncludes({
+            _tables: ["incident", "sys_hub_flow"],
+            _readOnlyTables: ["sys_hub_flow"],
+            _scopes: {
+                x_cadso_core: {
+                    _readOnlyTables: ["sys_hub_action_instance"],
+                },
+            },
+        });
+        const resolved = (0, config_1.resolveConfigForScope)("x_cadso_other", cfg);
+        expect(resolved.readOnlyTables).toEqual(["sys_hub_flow"]);
+    });
+    it("ignores non-array _readOnlyTables values safely", () => {
+        const cfg = withIncludes({
+            _tables: ["incident"],
+            _readOnlyTables: "oops-not-an-array",
+        });
+        const resolved = (0, config_1.resolveConfigForScope)("any_scope", cfg);
+        expect(resolved.readOnlyTables).toEqual([]);
+    });
+});