@tenonhq/sincronia-core 0.0.83 → 0.0.84

package/dist/appUtils.js

@@ -715,12 +715,37 @@ const pushFiles = async (recs) => {
             .join(", ");
         Logger_1.logger.info(`Update set routing active: ${activeScopes}`);
     }
+    // Pre-resolve read-only table sets for every scope present in this batch.
+    // Cheaper than re-resolving per record. Tables flagged in _readOnlyTables
+    // are pulled normally but pushes are skipped.
+    const readOnlyByScope = {};
+    for (const rec of recs) {
+        const fieldNames = Object.keys(rec.fields);
+        if (fieldNames.length === 0)
+            continue;
+        const scope = rec.fields[fieldNames[0]].scope;
+        if (scope && !readOnlyByScope[scope]) {
+            readOnlyByScope[scope] = ConfigManager.getReadOnlyTablesForScope(scope);
+        }
+    }
+    const announcedSkipTables = {};
     const tick = getProgTick(Logger_1.logger.getLogLevel(), recs.length * 2) || (() => { });
     const results = await (0, genericUtils_1.allSettledBatched)(recs, constants_1.CONCURRENCY_PUSH, async function (rec) {
         const fieldNames = Object.keys(rec.fields);
         const firstField = rec.fields[fieldNames[0]];
         const recSummary = (0, exports.summarizeRecord)(rec.table, firstField.name);
         const scope = firstField.scope;
+        const readOnlySet = scope ? readOnlyByScope[scope] : undefined;
+        if (readOnlySet && readOnlySet.has(rec.table)) {
+            tick();
+            tick();
+            const skipKey = `${scope}:${rec.table}`;
+            if (!announcedSkipTables[skipKey]) {
+                announcedSkipTables[skipKey] = true;
+                Logger_1.logger.info(`Read-only table ${rec.table} in scope ${scope}: push skipped`);
+            }
+            return { success: true, message: `${recSummary} : skipped (read-only table)` };
+        }
         const buildRes = await buildRec(rec);
         tick();
         if (!buildRes.success) {

package/dist/config.js

@@ -61,6 +61,7 @@ exports.resolveScopeFromPath = resolveScopeFromPath;
 exports.isDirectiveKey = isDirectiveKey;
 exports.stripDirectiveKeys = stripDirectiveKeys;
 exports.resolveConfigForScope = resolveConfigForScope;
+exports.getReadOnlyTablesForScope = getReadOnlyTablesForScope;
 const path_1 = __importDefault(require("path"));
 const fs_1 = require("fs");
 const Logger_1 = require("./Logger");
@@ -559,8 +560,8 @@ function stripDirectiveKeys(obj) {
     }
     return result;
 }
-function resolveConfigForScope(scopeName) {
-    var cfg = getConfig();
+function resolveConfigForScope(scopeName, cfgOverride) {
+    var cfg = cfgOverride || getConfig();
     var cfgIncludes = cfg.includes || {};
     var cfgExcludes = cfg.excludes || {};
     // Backward compat: support old "table" key (no underscore)
@@ -639,10 +640,40 @@ function resolveConfigForScope(scopeName) {
     var apiIncludes = Object.assign({}, fieldOverrides);
     // API excludes: strip _ keys
     var apiExcludes = stripDirectiveKeys(cfgExcludes);
+    // Read-only tables: union of global _readOnlyTables and scope-level override.
+    // A table flagged read-only is still pulled from the instance but pushes are
+    // skipped. Default when absent: empty (bidirectional for all tables).
+    var globalReadOnly = Array.isArray(cfgIncludes._readOnlyTables)
+        ? cfgIncludes._readOnlyTables
+        : [];
+    var scopeReadOnly = Array.isArray(scopeOverride._readOnlyTables)
+        ? scopeOverride._readOnlyTables
+        : [];
+    var readOnlySet = {};
+    for (i = 0; i < globalReadOnly.length; i++) {
+        readOnlySet[globalReadOnly[i]] = true;
+    }
+    for (i = 0; i < scopeReadOnly.length; i++) {
+        readOnlySet[scopeReadOnly[i]] = true;
+    }
+    var resolvedReadOnly = Object.keys(readOnlySet);
     return {
         tables: resolvedTables,
         fieldOverrides: fieldOverrides,
         apiIncludes: apiIncludes,
         apiExcludes: apiExcludes,
+        readOnlyTables: resolvedReadOnly,
     };
 }
+// Convenience wrapper for push-side lookups — returns a Set for O(1) membership.
+// Fails safe (empty set = all tables writable) when config isn't available
+// rather than blocking a push over a lookup error.
+function getReadOnlyTablesForScope(scopeName) {
+    try {
+        var resolved = resolveConfigForScope(scopeName);
+        return new Set(resolved.readOnlyTables || []);
+    }
+    catch (e) {
+        return new Set();
+    }
+}

package/dist/flowDesigner/values.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeV2Values = decodeV2Values;
+exports.encodeV2Values = encodeV2Values;
+const zlib_1 = require("zlib");
+/**
+ * Decode a ServiceNow V2 Flow Designer `values` blob.
+ *
+ * Source tables:
+ *   - sys_hub_action_instance_v2.values
+ *   - sys_hub_trigger_instance_v2.values
+ *   - sys_hub_flow_logic_instance_v2.values
+ *
+ * Storage format: base64-encoded gzipped JSON.
+ * Mirrors `GlideStringUtil.base64DecodeAsBytes()` + `GlideCompressionUtil.expandToString()`
+ * + `JSON.parse` on the ServiceNow platform.
+ *
+ * Throws with a clear message if the blob is empty, not base64, or not gzip.
+ */
+function decodeV2Values(blob) {
+    if (typeof blob !== "string" || blob.trim().length === 0) {
+        throw new Error("decodeV2Values: blob must be a non-empty string");
+    }
+    let buf;
+    try {
+        buf = Buffer.from(blob.trim(), "base64");
+    }
+    catch (err) {
+        throw new Error("decodeV2Values: blob is not valid base64");
+    }
+    let json;
+    try {
+        json = (0, zlib_1.gunzipSync)(buf).toString("utf8");
+    }
+    catch (err) {
+        throw new Error("decodeV2Values: decompression failed (input is not valid gzip after base64 decode)");
+    }
+    try {
+        return JSON.parse(json);
+    }
+    catch (err) {
+        throw new Error("decodeV2Values: decompressed body is not valid JSON");
+    }
+}
+/**
+ * Encode a V2 values payload back to ServiceNow's storage format.
+ *
+ * Inverse of decodeV2Values. Provided for symmetry, diagnostic round-trip
+ * tests, and any future write path. Current Craftsman sync treats sys_hub_*
+ * as _readOnlyTables, so this is not invoked on the push path today.
+ */
+function encodeV2Values(value) {
+    const json = JSON.stringify(value);
+    return (0, zlib_1.gzipSync)(Buffer.from(json, "utf8")).toString("base64");
+}

package/dist/index.js

@@ -1,14 +1,25 @@
 #!/usr/bin/env node
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeV2Values = exports.decodeV2Values = void 0;
 const bootstrap_1 = require("./bootstrap");
 const FileLogger_1 = require("./FileLogger");
+// Library exports — consumers can `import { decodeV2Values } from "@tenonhq/sincronia-core"`.
+// Keep exports above the CLI entry so bundlers/TS can tree-shake and require() consumers
+// never accidentally invoke main().
+var values_1 = require("./flowDesigner/values");
+Object.defineProperty(exports, "decodeV2Values", { enumerable: true, get: function () { return values_1.decodeV2Values; } });
+Object.defineProperty(exports, "encodeV2Values", { enumerable: true, get: function () { return values_1.encodeV2Values; } });
 async function main() {
     // Initialize file logging as early as possible
     FileLogger_1.fileLogger.info("Starting Sincronia...");
     await (0, bootstrap_1.init)();
 }
-main().catch(function (e) {
-    FileLogger_1.fileLogger.error("Fatal error: " + String(e));
-    process.exit(1);
-});
+// Only run the CLI when this file is executed directly (e.g. `npx sinc`, `node dist/index.js`).
+// When imported as a library, require.main !== module and main() is skipped.
+if (require.main === module) {
+    main().catch(function (e) {
+        FileLogger_1.fileLogger.error("Fatal error: " + String(e));
+        process.exit(1);
+    });
+}

package/dist/tests/pushFiles.test.js

@@ -3,6 +3,9 @@ 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 {
@@ -22,6 +25,16 @@ jest.mock("fs", function () {
         },
     };
 });
+// 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" } },
@@ -98,6 +111,7 @@ describe("pushFiles", function () {
     beforeEach(function () {
         configReadCount = 0;
         mockConfigData = {};
+        mockReadOnlyByScope = {};
         mockPushWithUpdateSet.mockClear();
         mockUpdateRecord.mockClear();
     });
@@ -159,4 +173,73 @@ describe("pushFiles", function () {
         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/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([]);
+    });
+});

package/dist/tests/v2Values.test.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const zlib_1 = require("zlib");
+const values_1 = require("../flowDesigner/values");
+describe("decodeV2Values / encodeV2Values", () => {
+    describe("round-trip", () => {
+        it("decodes what encodeV2Values encoded (primitive array)", () => {
+            const original = [
+                { actionInstanceSysId: "abc", id: "1", name: "to", value: "user@example.com" },
+                { actionInstanceSysId: "abc", id: "2", name: "subject", value: "hi" },
+            ];
+            const blob = (0, values_1.encodeV2Values)(original);
+            expect((0, values_1.decodeV2Values)(blob)).toEqual(original);
+        });
+        it("decodes what encodeV2Values encoded (nested parameter objects)", () => {
+            const original = [
+                {
+                    actionInstanceSysId: "abc123",
+                    id: "input_a",
+                    name: "record",
+                    value: { table: "incident", sys_id: "xyz" },
+                    parameter: {
+                        type: "reference",
+                        labels: { en: "Record" },
+                        validation: { mandatory: true },
+                    },
+                },
+            ];
+            const blob = (0, values_1.encodeV2Values)(original);
+            expect((0, values_1.decodeV2Values)(blob)).toEqual(original);
+        });
+        it("handles empty array", () => {
+            expect((0, values_1.decodeV2Values)((0, values_1.encodeV2Values)([]))).toEqual([]);
+        });
+        it("handles large payloads without truncation", () => {
+            const big = Array.from({ length: 500 }, (_, i) => ({
+                id: String(i),
+                name: "field_" + i,
+                value: "x".repeat(200),
+            }));
+            expect((0, values_1.decodeV2Values)((0, values_1.encodeV2Values)(big))).toEqual(big);
+        });
+    });
+    describe("decode — input validation", () => {
+        it("throws on empty string", () => {
+            expect(() => (0, values_1.decodeV2Values)("")).toThrow(/non-empty string/);
+        });
+        it("throws on whitespace-only string", () => {
+            expect(() => (0, values_1.decodeV2Values)("   \n  ")).toThrow(/non-empty string/);
+        });
+        it("throws on non-string input", () => {
+            expect(() => (0, values_1.decodeV2Values)(null)).toThrow(/non-empty string/);
+            expect(() => (0, values_1.decodeV2Values)(undefined)).toThrow(/non-empty string/);
+            expect(() => (0, values_1.decodeV2Values)(123)).toThrow(/non-empty string/);
+        });
+        it("throws with a clear message on non-gzip base64 input", () => {
+            // Valid base64, but the decoded bytes are not gzip.
+            const notGzip = Buffer.from("hello world").toString("base64");
+            expect(() => (0, values_1.decodeV2Values)(notGzip)).toThrow(/decompression failed/);
+        });
+        it("throws on gzip of invalid JSON", () => {
+            const badJson = (0, zlib_1.gzipSync)(Buffer.from("{not valid json", "utf8")).toString("base64");
+            expect(() => (0, values_1.decodeV2Values)(badJson)).toThrow(/not valid JSON/);
+        });
+        it("tolerates trailing whitespace and newlines (common from file reads)", () => {
+            const blob = (0, values_1.encodeV2Values)([{ id: "1", value: "a" }]);
+            expect((0, values_1.decodeV2Values)(blob + "\n")).toEqual([{ id: "1", value: "a" }]);
+            expect((0, values_1.decodeV2Values)("  " + blob + "  ")).toEqual([{ id: "1", value: "a" }]);
+        });
+    });
+    describe("generic typing", () => {
+        it("preserves the caller's expected type", () => {
+            const blob = (0, values_1.encodeV2Values)([{ actionInstanceSysId: "a", id: "1" }]);
+            const decoded = (0, values_1.decodeV2Values)(blob);
+            expect(decoded[0].actionInstanceSysId).toBe("a");
+            expect(decoded[0].id).toBe("1");
+        });
+    });
+});

package/package.json

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