@tenonhq/sincronia-core 0.0.19 → 0.0.22

package/dist/MultiScopeWatcher.js

@@ -0,0 +1,311 @@
+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 };
+};
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "chokidar", "./logMessages", "lodash", "./FileUtils", "./appUtils", "./Logger", "path", "./config"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    var __syncRequire = typeof module === "object" && typeof module.exports === "object";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.multiScopeWatcher = void 0;
+    exports.startMultiScopeWatching = startMultiScopeWatching;
+    exports.stopMultiScopeWatching = stopMultiScopeWatching;
+    const chokidar_1 = __importDefault(require("chokidar"));
+    const logMessages_1 = require("./logMessages");
+    const lodash_1 = require("lodash");
+    const FileUtils_1 = require("./FileUtils");
+    const appUtils_1 = require("./appUtils");
+    const Logger_1 = require("./Logger");
+    const path = __importStar(require("path"));
+    const ConfigManager = __importStar(require("./config"));
+    const DEBOUNCE_MS = 300;
+    class MultiScopeWatcherManager {
+        constructor() {
+            this.scopeWatchers = new Map();
+            this.updateSetCheckInterval = null;
+        }
+        async startWatchingAllScopes() {
+            try {
+                // Load configuration
+                await ConfigManager.loadConfigs();
+                const config = ConfigManager.getConfig();
+                if (!config.scopes) {
+                    Logger_1.logger.error("No scopes defined in sinc.config.js");
+                    throw new Error("No scopes defined in configuration");
+                }
+                const scopes = Object.keys(config.scopes);
+                Logger_1.logger.info(`Starting multi-scope watch for ${scopes.length} scopes: ${scopes.join(", ")}`);
+                // Start watching each scope
+                for (const scopeName of scopes) {
+                    const scopeConfig = config.scopes[scopeName];
+                    let sourceDirectory;
+                    if (typeof scopeConfig === "object" && scopeConfig.sourceDirectory) {
+                        sourceDirectory = path.resolve(ConfigManager.getRootDir(), scopeConfig.sourceDirectory);
+                    }
+                    else {
+                        // Default to src/{scope} if no sourceDirectory specified
+                        sourceDirectory = path.resolve(ConfigManager.getRootDir(), "src", scopeName);
+                    }
+                    this.startWatchingScope(scopeName, sourceDirectory);
+                }
+                // Start periodic update set checking
+                this.startUpdateSetMonitoring();
+                Logger_1.logger.success("✅ Multi-scope watch started successfully!");
+                Logger_1.logger.info("Watching for file changes across all scopes...");
+                Logger_1.logger.info("Press Ctrl+C to stop watching\n");
+            }
+            catch (error) {
+                Logger_1.logger.error("Failed to start multi-scope watch: " + error);
+                throw error;
+            }
+        }
+        startWatchingScope(scopeName, sourceDirectory) {
+            Logger_1.logger.info(`Setting up watcher for scope ${scopeName} in ${sourceDirectory}`);
+            const watcher = chokidar_1.default.watch(sourceDirectory, {
+                persistent: true,
+                ignoreInitial: true,
+                awaitWriteFinish: {
+                    stabilityThreshold: 300,
+                    pollInterval: 100
+                }
+            });
+            const scopeWatcher = {
+                scope: scopeName,
+                watcher: watcher,
+                pushQueue: [],
+                sourceDirectory: sourceDirectory
+            };
+            // Create a debounced processor for this scope
+            const processQueue = (0, lodash_1.debounce)(async () => {
+                await this.processScopeQueue(scopeWatcher);
+            }, DEBOUNCE_MS);
+            watcher.on("change", (filePath) => {
+                Logger_1.logger.info(`[${scopeName}] File changed: ${path.relative(sourceDirectory, filePath)}`);
+                scopeWatcher.pushQueue.push(filePath);
+                processQueue();
+            });
+            watcher.on("add", (filePath) => {
+                Logger_1.logger.info(`[${scopeName}] File added: ${path.relative(sourceDirectory, filePath)}`);
+                scopeWatcher.pushQueue.push(filePath);
+                processQueue();
+            });
+            watcher.on("error", (error) => {
+                Logger_1.logger.error(`[${scopeName}] Watcher error: ${error.message}`);
+            });
+            this.scopeWatchers.set(scopeName, scopeWatcher);
+        }
+        async processScopeQueue(scopeWatcher) {
+            if (scopeWatcher.pushQueue.length === 0)
+                return;
+            const toProcess = Array.from(new Set([...scopeWatcher.pushQueue]));
+            scopeWatcher.pushQueue = [];
+            Logger_1.logger.info(`[${scopeWatcher.scope}] Processing ${toProcess.length} file(s)...`);
+            try {
+                // First, switch to the correct scope
+                await this.switchToScope(scopeWatcher.scope);
+                // Process the files
+                const fileContexts = toProcess
+                    .map(FileUtils_1.getFileContextFromPath)
+                    .filter((ctx) => !!ctx);
+                if (fileContexts.length === 0) {
+                    Logger_1.logger.warn(`[${scopeWatcher.scope}] No valid file contexts found`);
+                    return;
+                }
+                const buildables = (0, appUtils_1.groupAppFiles)(fileContexts);
+                const updateResults = await (0, appUtils_1.pushFiles)(buildables);
+                updateResults.forEach((res, index) => {
+                    if (index < fileContexts.length) {
+                        (0, logMessages_1.logFilePush)(fileContexts[index], res);
+                    }
+                });
+                Logger_1.logger.success(`[${scopeWatcher.scope}] Successfully pushed ${updateResults.length} file(s)`);
+            }
+            catch (error) {
+                Logger_1.logger.error(`[${scopeWatcher.scope}] Error processing queue: ${error}`);
+            }
+        }
+        async switchToScope(scopeName) {
+            try {
+                const { defaultClient, unwrapSNResponse } = await (__syncRequire ? Promise.resolve().then(() => __importStar(require("./snClient"))) : new Promise((resolve_1, reject_1) => { require(["./snClient"], resolve_1, reject_1); }).then(__importStar));
+                const client = defaultClient();
+                // Get the scope ID
+                const scopeResponse = await unwrapSNResponse(client.getScopeId(scopeName));
+                if (!scopeResponse || !Array.isArray(scopeResponse) || scopeResponse.length === 0 || !scopeResponse[0].sys_id) {
+                    throw new Error(`Scope ${scopeName} not found`);
+                }
+                // Get user sys_id
+                const userResponse = await unwrapSNResponse(client.getUserSysId());
+                if (!userResponse || !Array.isArray(userResponse) || userResponse.length === 0 || !userResponse[0].sys_id) {
+                    throw new Error("Could not get user sys_id");
+                }
+                // Get current app preference
+                const prefResponse = await unwrapSNResponse(client.getCurrentAppUserPrefSysId(userResponse[0].sys_id));
+                if (prefResponse && Array.isArray(prefResponse) && prefResponse.length > 0 && prefResponse[0].sys_id) {
+                    // Update existing preference
+                    await client.updateCurrentAppUserPref(scopeResponse[0].sys_id, prefResponse[0].sys_id);
+                }
+                else {
+                    // Create new preference
+                    await client.createCurrentAppUserPref(scopeResponse[0].sys_id, userResponse[0].sys_id);
+                }
+                Logger_1.logger.debug(`Switched to scope: ${scopeName}`);
+            }
+            catch (error) {
+                Logger_1.logger.error(`Failed to switch to scope ${scopeName}: ${error}`);
+                throw error;
+            }
+        }
+        async startUpdateSetMonitoring() {
+            // Check update sets immediately on start
+            await this.checkAllUpdateSets();
+            // Then check every 30 seconds
+            this.updateSetCheckInterval = setInterval(async () => {
+                await this.checkAllUpdateSets();
+            }, 30000);
+        }
+        async checkAllUpdateSets() {
+            try {
+                const { defaultClient, unwrapSNResponse } = await (__syncRequire ? Promise.resolve().then(() => __importStar(require("./snClient"))) : new Promise((resolve_2, reject_2) => { require(["./snClient"], resolve_2, reject_2); }).then(__importStar));
+                const client = defaultClient();
+                const config = ConfigManager.getConfig();
+                if (!config.scopes)
+                    return;
+                const scopes = Object.keys(config.scopes);
+                Logger_1.logger.info("\n" + "=".repeat(60));
+                Logger_1.logger.info("Update Set Status Check");
+                Logger_1.logger.info("=".repeat(60));
+                for (const scopeName of scopes) {
+                    try {
+                        // Switch to scope to check its update set
+                        await this.switchToScope(scopeName);
+                        // Get user sys_id
+                        const userResponse = await unwrapSNResponse(client.getUserSysId());
+                        if (!userResponse || !Array.isArray(userResponse) || userResponse.length === 0 || !userResponse[0].sys_id) {
+                            Logger_1.logger.warn(`[${scopeName}] Could not get user information`);
+                            continue;
+                        }
+                        // Get current update set preference
+                        const updateSetPref = await unwrapSNResponse(client.getCurrentUpdateSetUserPref(userResponse[0].sys_id));
+                        if (updateSetPref && Array.isArray(updateSetPref) && updateSetPref.length > 0 && updateSetPref[0].value) {
+                            // Get update set details
+                            const updateSetId = updateSetPref[0].value;
+                            const updateSetDetails = await this.getUpdateSetDetails(updateSetId);
+                            if (updateSetDetails) {
+                                const isDefault = updateSetDetails.name === "Default" ||
+                                    updateSetDetails.name.toLowerCase().includes("default");
+                                if (isDefault) {
+                                    Logger_1.logger.warn(`⚠️  [${scopeName}] Currently in DEFAULT update set!`);
+                                }
+                                else {
+                                    Logger_1.logger.info(`✅ [${scopeName}] Update Set: ${updateSetDetails.name}`);
+                                }
+                            }
+                            else {
+                                Logger_1.logger.info(`[${scopeName}] Update Set ID: ${updateSetId}`);
+                            }
+                        }
+                        else {
+                            Logger_1.logger.warn(`⚠️  [${scopeName}] No update set selected or in DEFAULT`);
+                        }
+                    }
+                    catch (error) {
+                        Logger_1.logger.error(`[${scopeName}] Error checking update set: ${error}`);
+                    }
+                }
+                Logger_1.logger.info("=".repeat(60) + "\n");
+            }
+            catch (error) {
+                Logger_1.logger.error(`Error during update set monitoring: ${error}`);
+            }
+        }
+        async getUpdateSetDetails(updateSetId) {
+            try {
+                const { defaultClient } = await (__syncRequire ? Promise.resolve().then(() => __importStar(require("./snClient"))) : new Promise((resolve_3, reject_3) => { require(["./snClient"], resolve_3, reject_3); }).then(__importStar));
+                const client = defaultClient();
+                // Create axios client directly to get update set details
+                const axios = (await (__syncRequire ? Promise.resolve().then(() => __importStar(require("axios"))) : new Promise((resolve_4, reject_4) => { require(["axios"], resolve_4, reject_4); }).then(__importStar))).default;
+                const { SN_USER = "", SN_PASSWORD = "", SN_INSTANCE = "" } = process.env;
+                const axiosClient = axios.create({
+                    auth: {
+                        username: SN_USER,
+                        password: SN_PASSWORD
+                    },
+                    baseURL: SN_INSTANCE
+                });
+                const response = await axiosClient.get(`/api/now/table/sys_update_set/${updateSetId}`, {
+                    params: {
+                        sysparm_fields: "name,state,sys_id"
+                    }
+                });
+                if (response.data && response.data.result) {
+                    return response.data.result;
+                }
+                return null;
+            }
+            catch (error) {
+                Logger_1.logger.debug(`Could not get update set details: ${error}`);
+                return null;
+            }
+        }
+        stopWatching() {
+            // Stop all scope watchers
+            for (const [scopeName, scopeWatcher] of this.scopeWatchers) {
+                Logger_1.logger.info(`Stopping watcher for scope: ${scopeName}`);
+                scopeWatcher.watcher.close();
+            }
+            this.scopeWatchers.clear();
+            // Stop update set monitoring
+            if (this.updateSetCheckInterval) {
+                clearInterval(this.updateSetCheckInterval);
+                this.updateSetCheckInterval = null;
+            }
+            Logger_1.logger.info("All watchers stopped");
+        }
+    }
+    exports.multiScopeWatcher = new MultiScopeWatcherManager();
+    function startMultiScopeWatching() {
+        return exports.multiScopeWatcher.startWatchingAllScopes();
+    }
+    function stopMultiScopeWatching() {
+        exports.multiScopeWatcher.stopWatching();
+    }
+});

package/dist/allScopesCommands.js

@@ -37,15 +37,16 @@ var __importStar = (this && this.__importStar) || (function () {
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "./Logger", "./config", "./FileUtils", "./snClient", "./commands", "path", "fs"], factory);
+        define(["require", "exports", "./Logger", "./config", "./snClient", "./commands", "path", "fs"], factory);
     }
 })(function (require, exports) {
     "use strict";
+    var __syncRequire = typeof module === "object" && typeof module.exports === "object";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.initScopesCommand = initScopesCommand;
+    exports.watchAllScopesCommand = watchAllScopesCommand;
     const Logger_1 = require("./Logger");
     const ConfigManager = __importStar(require("./config"));
-    const fUtils = __importStar(require("./FileUtils"));
     const snClient_1 = require("./snClient");
     const commands_1 = require("./commands");
     const path = __importStar(require("path"));
@@ -53,24 +54,62 @@ var __importStar = (this && this.__importStar) || (function () {
     const fsp = fs.promises;
     // Custom function to process manifest with specific source directory
     async function processManifestForScope(manifest, sourceDirectory, forceWrite = false) {
-        // Process each table in the manifest
-        const tables = manifest.tables || {};
-        const tableNames = Object.keys(tables);
-        for (const tableName of tableNames) {
-            const tableRecords = tables[tableName];
-            const tablePath = path.join(sourceDirectory, tableName);
-            // Process each record in the table
-            const recordNames = Object.keys(tableRecords.records || {});
-            for (const recordName of recordNames) {
-                const record = tableRecords.records[recordName];
-                // Process each file in the record
-                for (const file of record.files || []) {
-                    const filePath = path.join(tablePath, recordName, `${file.name}.${file.type}`);
-                    const fileContent = file.content || "";
-                    // Create the file
-                    await fUtils.writeFileForce(filePath, fileContent);
+        var _a;
+        try {
+            // Ensure the source directory exists
+            Logger_1.logger.info(`Creating source directory: ${sourceDirectory}`);
+            try {
+                await fsp.mkdir(sourceDirectory, { recursive: true });
+                Logger_1.logger.info(`Successfully created directory: ${sourceDirectory}`);
+            }
+            catch (dirError) {
+                Logger_1.logger.error(`Failed to create source directory ${sourceDirectory}: ${dirError}`);
+                throw dirError;
+            }
+            // Process each table in the manifest
+            const tables = manifest.tables || {};
+            const tableNames = Object.keys(tables);
+            Logger_1.logger.info(`Processing ${tableNames.length} tables`);
+            Logger_1.logger.debug(`Table names: ${tableNames.join(', ')}`);
+            for (const tableName of tableNames) {
+                const tableRecords = tables[tableName];
+                const tablePath = path.join(sourceDirectory, tableName);
+                // Process each record in the table
+                const recordNames = Object.keys(tableRecords.records || {});
+                Logger_1.logger.debug(`Processing ${recordNames.length} records in table ${tableName}`);
+                for (const recordName of recordNames) {
+                    const record = tableRecords.records[recordName];
+                    // Use the record's name property instead of the key for the directory name
+                    const recordDirName = record.name || recordName;
+                    const recordPath = path.join(tablePath, recordDirName);
+                    Logger_1.logger.debug(`Processing record: ${recordDirName} with ${((_a = record.files) === null || _a === void 0 ? void 0 : _a.length) || 0} files`);
+                    // Ensure the record directory exists
+                    await fsp.mkdir(recordPath, { recursive: true });
+                    // Process each file in the record
+                    for (const file of record.files || []) {
+                        const filePath = path.join(recordPath, `${file.name}.${file.type}`);
+                        const fileContent = file.content || "";
+                        // Ensure the parent directory exists before writing the file
+                        const fileDir = path.dirname(filePath);
+                        Logger_1.logger.debug(`Creating directory: ${fileDir}`);
+                        await fsp.mkdir(fileDir, { recursive: true });
+                        // Create the file
+                        Logger_1.logger.debug(`Writing file: ${filePath}`);
+                        try {
+                            await fsp.writeFile(filePath, fileContent, 'utf8');
+                        }
+                        catch (writeError) {
+                            Logger_1.logger.error(`Failed to write file ${filePath}: ${writeError}`);
+                            throw writeError;
+                        }
+                    }
                 }
             }
+            Logger_1.logger.info(`Successfully processed files for ${sourceDirectory}`);
+        }
+        catch (error) {
+            Logger_1.logger.error(`Error in processManifestForScope: ${error}`);
+            throw error;
         }
     }
     async function processScope(scopeName, scopeConfig) {
@@ -106,6 +145,7 @@ var __importStar = (this && this.__importStar) || (function () {
             const manifest = await (0, snClient_1.unwrapSNResponse)(client.getManifest(scopeName, config, true));
             // Process the manifest to create local files in the correct directory
             Logger_1.logger.info(`Processing manifest and creating local files for ${scopeName}...`);
+            Logger_1.logger.info(`Manifest has ${Object.keys((manifest === null || manifest === void 0 ? void 0 : manifest.tables) || {}).length} tables`);
             await processManifestForScope(manifest, sourceDirectory, true);
             // Create the scope-specific manifest structure
             const scopeManifest = {
@@ -180,11 +220,36 @@ var __importStar = (this && this.__importStar) || (function () {
             }
             Logger_1.logger.info(`Manifest written to: ${manifestPath}`);
             Logger_1.logger.info("\nAll scope files have been downloaded to their respective source directories.");
-            Logger_1.logger.success("\nYou can now use 'npx sinc dev' to start development mode!");
+            Logger_1.logger.success("\nYou can now use 'npx sinc watchAllScopes' to start development mode!");
         }
         catch (e) {
             Logger_1.logger.error("Error initializing scopes: " + e);
             throw e;
         }
     }
+    async function watchAllScopesCommand(args) {
+        (0, commands_1.setLogLevel)(args);
+        try {
+            // First check if we have environment variables set
+            if (!process.env.SN_USER || !process.env.SN_PASSWORD || !process.env.SN_INSTANCE) {
+                Logger_1.logger.error("Missing ServiceNow credentials. Please ensure SN_USER, SN_PASSWORD, and SN_INSTANCE are set in your .env file");
+                throw new Error("ServiceNow credentials not configured");
+            }
+            // Import and start the multi-scope watcher
+            const { startMultiScopeWatching } = await (__syncRequire ? Promise.resolve().then(() => __importStar(require("./MultiScopeWatcher"))) : new Promise((resolve_1, reject_1) => { require(["./MultiScopeWatcher"], resolve_1, reject_1); }).then(__importStar));
+            // Start watching all scopes
+            await startMultiScopeWatching();
+            // Keep the process running
+            process.on("SIGINT", async () => {
+                Logger_1.logger.info("\nStopping multi-scope watch...");
+                const { stopMultiScopeWatching } = await (__syncRequire ? Promise.resolve().then(() => __importStar(require("./MultiScopeWatcher"))) : new Promise((resolve_2, reject_2) => { require(["./MultiScopeWatcher"], resolve_2, reject_2); }).then(__importStar));
+                stopMultiScopeWatching();
+                process.exit(0);
+            });
+        }
+        catch (error) {
+            Logger_1.logger.error("Failed to start multi-scope watch: " + error);
+            throw error;
+        }
+    }
 });

package/dist/commander.js

@@ -61,6 +61,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
         })
             .command("init", "Provisions an initial project for you", sharedOptions, commands_1.initCommand)
             .command("initScopes", "Provisions an initial project for the scopes defined in the config", sharedOptions, allScopesCommands_1.initScopesCommand)
+            .command("watchAllScopes", "Watch all scopes for file changes and display update set status", sharedOptions, allScopesCommands_1.watchAllScopesCommand)
             .command("build", "Build application files locally", (cmdArgs) => {
             cmdArgs.options({
                 ...sharedOptions,

package/package.json

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