@tenonhq/dovetail-core 0.0.85

package/dist/tests/globalDebounce.test.js

@@ -0,0 +1,308 @@
+"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;
+        }),
+    };
+});
+// Capture debounce calls to verify single global debounce
+var capturedDebounceFns = [];
+jest.mock("lodash", function () {
+    var actual = jest.requireActual("lodash");
+    return {
+        ...actual,
+        debounce: jest.fn(function (fn) {
+            capturedDebounceFns.push(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(),
+    changeScope: jest.fn().mockResolvedValue(undefined),
+};
+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(),
+        statSync: jest.fn().mockReturnValue({ mtimeMs: Date.now() }),
+        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 fs_1 = __importDefault(require("fs"));
+const ConfigManager = __importStar(require("../config"));
+const FileUtils_1 = require("../FileUtils");
+const appUtils_1 = require("../appUtils");
+const MultiScopeWatcher_1 = require("../MultiScopeWatcher");
+// --- Fixtures ---
+var makeFileContext = function (overrides) {
+    return Object.assign({
+        filePath: "/project/src/x_test_core/sys_script_include/TestScript/script.js",
+        ext: ".js",
+        sys_id: "abc123",
+        name: "TestScript",
+        scope: "x_test_core",
+        tableName: "sys_script_include",
+        targetField: "script",
+    }, overrides || {});
+};
+var TWO_SCOPES_CONFIG = {
+    sourceDirectory: "src",
+    buildDirectory: "build",
+    rules: [],
+    includes: {},
+    excludes: {},
+    tableOptions: {},
+    refreshInterval: 30,
+    scopes: {
+        x_scope_a: { sourceDirectory: "src/x_scope_a" },
+        x_scope_b: { sourceDirectory: "src/x_scope_b" },
+    },
+};
+// --- Tests ---
+describe("US-014: Global debounce for serialized scope processing", function () {
+    beforeEach(function () {
+        jest.clearAllMocks();
+        mockWatchers.length = 0;
+        capturedDebounceFns.length = 0;
+        (0, MultiScopeWatcher_1.stopMultiScopeWatching)();
+        MultiScopeWatcher_1.multiScopeWatcher.cachedScope = null;
+        MultiScopeWatcher_1.multiScopeWatcher.cachedUserSysId = null;
+        MultiScopeWatcher_1.multiScopeWatcher.pendingScopes = new Map();
+        MultiScopeWatcher_1.multiScopeWatcher.globalProcessQueue = null;
+        // Default scope switching succeeds
+        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.createCurrentAppUserPref.mockResolvedValue({});
+        fs_1.default.existsSync.mockReturnValue(false);
+    });
+    afterEach(function () {
+        (0, MultiScopeWatcher_1.stopMultiScopeWatching)();
+        jest.useRealTimers();
+    });
+    it("creates a single global debounce, not one per scope", async function () {
+        ConfigManager.getConfig.mockReturnValue(TWO_SCOPES_CONFIG);
+        await (0, MultiScopeWatcher_1.startMultiScopeWatching)({ monitorIntervalMs: 0 });
+        // Two scopes but only one debounce function captured
+        expect(capturedDebounceFns.length).toBe(1);
+    });
+    it("processes multiple scopes triggered within debounce window in a single batch", async function () {
+        ConfigManager.getConfig.mockReturnValue(TWO_SCOPES_CONFIG);
+        var ctxA = makeFileContext({ scope: "x_scope_a", filePath: "/project/src/x_scope_a/sys_script_include/A/script.js" });
+        var ctxB = makeFileContext({ scope: "x_scope_b", filePath: "/project/src/x_scope_b/sys_script_include/B/script.js" });
+        FileUtils_1.getFileContextWithSkipReason.mockImplementation(function (fp) {
+            if (fp.indexOf("x_scope_a") !== -1)
+                return { context: ctxA };
+            if (fp.indexOf("x_scope_b") !== -1)
+                return { context: ctxB };
+            return { skipReason: "unknown" };
+        });
+        appUtils_1.groupAppFiles.mockReturnValue([{ table: "sys_script_include", sysId: "abc123", fields: {} }]);
+        appUtils_1.pushFiles.mockResolvedValue([{ success: true, message: "ok" }]);
+        await (0, MultiScopeWatcher_1.startMultiScopeWatching)({ monitorIntervalMs: 0 });
+        // Emit changes in both scopes before debounce fires
+        mockWatchers[0]._emit("change", ctxA.filePath);
+        mockWatchers[1]._emit("change", ctxB.filePath);
+        // Fire the single global debounce
+        await capturedDebounceFns[0]();
+        // Both scopes should have been processed (pushFiles called twice — once per scope)
+        expect(appUtils_1.pushFiles).toHaveBeenCalledTimes(2);
+    });
+    it("processes scopes in FIFO order by first file change timestamp", async function () {
+        ConfigManager.getConfig.mockReturnValue(TWO_SCOPES_CONFIG);
+        var ctxA = makeFileContext({ scope: "x_scope_a", filePath: "/project/src/x_scope_a/sys_script_include/A/script.js" });
+        var ctxB = makeFileContext({ scope: "x_scope_b", filePath: "/project/src/x_scope_b/sys_script_include/B/script.js" });
+        FileUtils_1.getFileContextWithSkipReason.mockImplementation(function (fp) {
+            if (fp.indexOf("x_scope_a") !== -1)
+                return { context: ctxA };
+            if (fp.indexOf("x_scope_b") !== -1)
+                return { context: ctxB };
+            return { skipReason: "unknown" };
+        });
+        appUtils_1.groupAppFiles.mockReturnValue([{ table: "sys_script_include", sysId: "abc123", fields: {} }]);
+        appUtils_1.pushFiles.mockResolvedValue([{ success: true, message: "ok" }]);
+        await (0, MultiScopeWatcher_1.startMultiScopeWatching)({ monitorIntervalMs: 0 });
+        // Scope B changes first, then scope A
+        // Use pendingScopes directly to control timestamps for deterministic ordering
+        MultiScopeWatcher_1.multiScopeWatcher.pendingScopes.set("x_scope_b", 1000);
+        MultiScopeWatcher_1.multiScopeWatcher.pendingScopes.set("x_scope_a", 2000);
+        // Add files to queues manually
+        var watcherA = MultiScopeWatcher_1.multiScopeWatcher.scopeWatchers.get("x_scope_a");
+        var watcherB = MultiScopeWatcher_1.multiScopeWatcher.scopeWatchers.get("x_scope_b");
+        watcherA.pushQueue.push(ctxA.filePath);
+        watcherB.pushQueue.push(ctxB.filePath);
+        // Track the order of scope switches
+        var switchOrder = [];
+        mockSNClient.changeScope.mockImplementation(function (scope) {
+            switchOrder.push(scope);
+            return Promise.resolve(undefined);
+        });
+        // Fire the global debounce
+        await capturedDebounceFns[0]();
+        // Scope B (timestamp 1000) should be processed before scope A (timestamp 2000)
+        expect(switchOrder[0]).toBe("x_scope_b");
+        expect(switchOrder[1]).toBe("x_scope_a");
+    });
+    it("clears pendingScopes after processing", async function () {
+        ConfigManager.getConfig.mockReturnValue(TWO_SCOPES_CONFIG);
+        var ctx = makeFileContext({ scope: "x_scope_a", filePath: "/project/src/x_scope_a/sys_script_include/A/script.js" });
+        FileUtils_1.getFileContextWithSkipReason.mockReturnValue({ context: ctx });
+        appUtils_1.groupAppFiles.mockReturnValue([{ table: "sys_script_include", sysId: "abc123", fields: {} }]);
+        appUtils_1.pushFiles.mockResolvedValue([{ success: true, message: "ok" }]);
+        await (0, MultiScopeWatcher_1.startMultiScopeWatching)({ monitorIntervalMs: 0 });
+        mockWatchers[0]._emit("change", ctx.filePath);
+        await capturedDebounceFns[0]();
+        expect(MultiScopeWatcher_1.multiScopeWatcher.pendingScopes.size).toBe(0);
+    });
+    it("only records first change timestamp per scope (not subsequent changes)", async function () {
+        ConfigManager.getConfig.mockReturnValue({
+            ...TWO_SCOPES_CONFIG,
+            scopes: { x_scope_a: { sourceDirectory: "src/x_scope_a" } },
+        });
+        await (0, MultiScopeWatcher_1.startMultiScopeWatching)({ monitorIntervalMs: 0 });
+        // Record the timestamp after first emit
+        mockWatchers[0]._emit("change", "/project/src/x_scope_a/sys_script_include/A/script.js");
+        var firstTimestamp = MultiScopeWatcher_1.multiScopeWatcher.pendingScopes.get("x_scope_a");
+        // Wait a bit and emit again
+        await new Promise(function (r) { setTimeout(r, 5); });
+        mockWatchers[0]._emit("change", "/project/src/x_scope_a/sys_script_include/B/script.js");
+        var secondTimestamp = MultiScopeWatcher_1.multiScopeWatcher.pendingScopes.get("x_scope_a");
+        // Timestamp should not have changed
+        expect(secondTimestamp).toBe(firstTimestamp);
+    });
+});

package/dist/tests/migrateCommand.test.js

@@ -0,0 +1,113 @@
+"use strict";
+// Tests for the `dove migrate` command (migrateCommand.ts). Covers: dry-run
+// no-op, --apply renames files and rewrites package.json deps + scripts,
+// collision safety (existing target skips rename), and the widened script
+// rewrite that catches mid-string sinc invocations (e.g. `&& sinc push`).
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var mockLogger = {
+    info: jest.fn(),
+    debug: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+    success: jest.fn(),
+    getLogLevel: function () { return "debug"; },
+};
+jest.mock("../Logger", function () {
+    return { logger: mockLogger };
+});
+jest.mock("../commands", function () {
+    return { setLogLevel: jest.fn() };
+});
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const migrateCommand_1 = require("../migrateCommand");
+function makeTempDir() {
+    return fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), "dove-migrate-test-"));
+}
+function rmrf(dir) {
+    fs_1.default.rmSync(dir, { recursive: true, force: true });
+}
+describe("migrateCommand", function () {
+    var origCwd = process.cwd();
+    var tmp = "";
+    beforeEach(function () {
+        jest.clearAllMocks();
+        tmp = makeTempDir();
+        process.chdir(tmp);
+    });
+    afterEach(function () {
+        process.chdir(origCwd);
+        rmrf(tmp);
+    });
+    it("dry-run makes zero filesystem changes", async function () {
+        fs_1.default.writeFileSync(path_1.default.join(tmp, "sinc.config.js"), "module.exports = {};\n");
+        fs_1.default.writeFileSync(path_1.default.join(tmp, "package.json"), JSON.stringify({ scripts: { build: "sinc push" }, devDependencies: { "@tenonhq/sincronia-core": "^1.0.0" } }, null, 2));
+        await (0, migrateCommand_1.migrateCommand)({});
+        expect(fs_1.default.existsSync(path_1.default.join(tmp, "sinc.config.js"))).toBe(true);
+        expect(fs_1.default.existsSync(path_1.default.join(tmp, "dove.config.js"))).toBe(false);
+        var pkg = JSON.parse(fs_1.default.readFileSync(path_1.default.join(tmp, "package.json"), "utf8"));
+        expect(pkg.scripts.build).toBe("sinc push");
+        expect(pkg.devDependencies["@tenonhq/sincronia-core"]).toBe("^1.0.0");
+    });
+    it("--apply renames sinc.* artifacts and rewrites package.json", async function () {
+        fs_1.default.writeFileSync(path_1.default.join(tmp, "sinc.config.js"), "module.exports = {};\n");
+        fs_1.default.writeFileSync(path_1.default.join(tmp, "sinc.manifest.json"), "{}\n");
+        fs_1.default.writeFileSync(path_1.default.join(tmp, ".sinc-active-task.json"), "{}\n");
+        fs_1.default.writeFileSync(path_1.default.join(tmp, "sinc.manifest.x_cadso_core.json"), "{}\n");
+        fs_1.default.writeFileSync(path_1.default.join(tmp, "package.json"), JSON.stringify({
+            scripts: { build: "sinc push", watch: "npx sinc watch" },
+            devDependencies: {
+                "@tenonhq/sincronia-core": "^1.0.0",
+                "@tenonhq/sincronia-types": "^1.0.0",
+            },
+        }, null, 2));
+        await (0, migrateCommand_1.migrateCommand)({ apply: true });
+        expect(fs_1.default.existsSync(path_1.default.join(tmp, "sinc.config.js"))).toBe(false);
+        expect(fs_1.default.existsSync(path_1.default.join(tmp, "dove.config.js"))).toBe(true);
+        expect(fs_1.default.existsSync(path_1.default.join(tmp, "dove.manifest.json"))).toBe(true);
+        expect(fs_1.default.existsSync(path_1.default.join(tmp, ".dove-active-task.json"))).toBe(true);
+        expect(fs_1.default.existsSync(path_1.default.join(tmp, "dove.manifest.x_cadso_core.json"))).toBe(true);
+        var pkg = JSON.parse(fs_1.default.readFileSync(path_1.default.join(tmp, "package.json"), "utf8"));
+        expect(pkg.scripts.build).toBe("dove push");
+        expect(pkg.scripts.watch).toBe("npx dove watch");
+        expect(pkg.devDependencies["@tenonhq/dovetail-core"]).toBe("^1.0.0");
+        expect(pkg.devDependencies["@tenonhq/dovetail-types"]).toBe("^1.0.0");
+        expect(pkg.devDependencies["@tenonhq/sincronia-core"]).toBeUndefined();
+    });
+    it("rewrites mid-string sinc invocations (chained commands)", async function () {
+        fs_1.default.writeFileSync(path_1.default.join(tmp, "package.json"), JSON.stringify({
+            scripts: {
+                deploy: "npm run build && sinc push && sinc deploy",
+                ci: "lint && test ; sinc status",
+                // Should not match `sincronia` (the package name appears in scripts via npx).
+                note: "echo @tenonhq/sincronia-core",
+            },
+        }, null, 2));
+        await (0, migrateCommand_1.migrateCommand)({ apply: true });
+        var pkg = JSON.parse(fs_1.default.readFileSync(path_1.default.join(tmp, "package.json"), "utf8"));
+        expect(pkg.scripts.deploy).toBe("npm run build && dove push && dove deploy");
+        expect(pkg.scripts.ci).toBe("lint && test ; dove status");
+        // \bsinc\b does not match `sincronia` (no word boundary between c and r),
+        // and @tenonhq/sincronia-* is rewritten to @tenonhq/dovetail-* by the
+        // earlier package-name pass.
+        expect(pkg.scripts.note).toBe("echo @tenonhq/dovetail-core");
+    });
+    it("skips rename when target file already exists and warns", async function () {
+        fs_1.default.writeFileSync(path_1.default.join(tmp, "sinc.config.js"), "// legacy\n");
+        fs_1.default.writeFileSync(path_1.default.join(tmp, "dove.config.js"), "// new\n");
+        await (0, migrateCommand_1.migrateCommand)({ apply: true });
+        expect(fs_1.default.readFileSync(path_1.default.join(tmp, "sinc.config.js"), "utf8")).toBe("// legacy\n");
+        expect(fs_1.default.readFileSync(path_1.default.join(tmp, "dove.config.js"), "utf8")).toBe("// new\n");
+        expect(mockLogger.warn).toHaveBeenCalledWith(expect.stringContaining("Skipping rename of sinc.config.js"));
+    });
+    it("reports nothing-to-migrate when project is already on dove.*", async function () {
+        fs_1.default.writeFileSync(path_1.default.join(tmp, "dove.config.js"), "module.exports = {};\n");
+        fs_1.default.writeFileSync(path_1.default.join(tmp, "package.json"), JSON.stringify({ scripts: { build: "dove push" }, devDependencies: { "@tenonhq/dovetail-core": "^1.0.0" } }, null, 2));
+        await (0, migrateCommand_1.migrateCommand)({ apply: true });
+        expect(mockLogger.success).toHaveBeenCalledWith(expect.stringContaining("Nothing to migrate"));
+    });
+});