@tenonhq/sincronia-core 0.0.44 → 0.0.45

package/dist/FileUtils.js

@@ -45,7 +45,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.writeFileForce = exports.writeSNFileForce = exports.writeSNFileIfNotExists = exports.writeBuildFile = exports.summarizeFile = exports.encodedPathsToFilePaths = exports.isValidPath = exports.splitEncodedPaths = exports.getPathsInPath = exports.isDirectory = exports.toAbsolutePath = exports.getFileContextFromPath = exports.getBuildExt = exports.isUnderPath = exports.appendToPath = exports.pathExists = exports.createDirRecursively = exports.writeSNFileCurry = exports.writeManifestFile = exports.SNFileExists = void 0;
+    exports.writeFileForce = exports.writeSNFileForce = exports.writeSNFileIfNotExists = exports.writeBuildFile = exports.summarizeFile = exports.encodedPathsToFilePaths = exports.isValidPath = exports.splitEncodedPaths = exports.getPathsInPath = exports.isDirectory = exports.toAbsolutePath = exports.getFileContextFromPath = exports.getBuildExt = exports.isUnderPath = exports.appendToPath = exports.pathExists = exports.createDirRecursively = exports.writeSNFileCurry = exports.writeScopeManifest = exports.writeManifestFile = exports.SNFileExists = void 0;
     const constants_1 = require("./constants");
     const fs_1 = __importStar(require("fs"));
     const path_1 = __importDefault(require("path"));
@@ -61,10 +61,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
         }
     };
     exports.SNFileExists = SNFileExists;
-    const writeManifestFile = async (man) => {
+    const writeManifestFile = async (man, scope) => {
+        if (scope) {
+            // Write scope-specific manifest
+            return fs_1.promises.writeFile(ConfigManager.getScopeManifestPath(scope), JSON.stringify(man, null, 2));
+        }
+        // Write legacy single manifest
         return fs_1.promises.writeFile(ConfigManager.getManifestPath(), JSON.stringify(man, null, 2));
     };
     exports.writeManifestFile = writeManifestFile;
+    const writeScopeManifest = async (scope, man) => {
+        return fs_1.promises.writeFile(ConfigManager.getScopeManifestPath(scope), JSON.stringify(man, null, 2));
+    };
+    exports.writeScopeManifest = writeScopeManifest;
     const writeSNFileCurry = (checkExists) => async (file, parentPath) => {
         let { name, type, content = "" } = file;
         // content can sometimes be null

package/dist/MultiScopeWatcher.js

@@ -142,6 +142,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
             try {
                 // First, switch to the correct scope
                 await this.switchToScope(scopeWatcher.scope);
+                // Load the manifest for this specific scope
+                await this.loadScopeManifest(scopeWatcher.scope, scopeWatcher.sourceDirectory);
                 // Process the files
                 const fileContexts = toProcess
                     .map(FileUtils_1.getFileContextFromPath)
@@ -163,9 +165,65 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
                 Logger_1.logger.error(`[${scopeWatcher.scope}] Error processing queue: ${error}`);
             }
         }
+        async loadScopeManifest(scopeName, sourceDirectory) {
+            try {
+                // The sourceDirectory is like /path/to/ServiceNow/src/x_cadso_core
+                // We need to go up two levels to get to the ServiceNow directory where manifests are stored
+                const projectRoot = path.dirname(path.dirname(sourceDirectory)); // Go up from src/scope to project root
+                const fs = await (__syncRequire ? Promise.resolve().then(() => __importStar(require("fs"))) : new Promise((resolve_1, reject_1) => { require(["fs"], resolve_1, reject_1); }).then(__importStar));
+                // First try to load scope-specific manifest file
+                const scopeManifestPath = path.join(projectRoot, `sinc.manifest.${scopeName}.json`);
+                if (fs.existsSync(scopeManifestPath)) {
+                    const manifestContent = await fs.promises.readFile(scopeManifestPath, "utf-8");
+                    const scopeManifest = JSON.parse(manifestContent);
+                    // Ensure scope field is set
+                    if (!scopeManifest.scope) {
+                        scopeManifest.scope = scopeName;
+                    }
+                    ConfigManager.updateManifest(scopeManifest);
+                    Logger_1.logger.debug(`Loaded scope-specific manifest for: ${scopeName}`);
+                    return;
+                }
+                // Fall back to checking legacy single manifest file
+                const manifestPath = path.join(projectRoot, "sinc.manifest.json");
+                if (fs.existsSync(manifestPath)) {
+                    const manifestContent = await fs.promises.readFile(manifestPath, "utf-8");
+                    const fullManifest = JSON.parse(manifestContent);
+                    // Check if this is a multi-scope manifest (has scopes as top-level keys)
+                    if (fullManifest[scopeName]) {
+                        // Multi-scope manifest - extract the specific scope's data
+                        const scopeManifest = fullManifest[scopeName];
+                        // Add the scope field for compatibility
+                        scopeManifest.scope = scopeName;
+                        ConfigManager.updateManifest(scopeManifest);
+                        Logger_1.logger.debug(`Loaded manifest for scope: ${scopeName} from legacy multi-scope manifest`);
+                    }
+                    else if (fullManifest.scope === scopeName) {
+                        // Single-scope manifest for the correct scope
+                        ConfigManager.updateManifest(fullManifest);
+                        Logger_1.logger.debug(`Loaded single-scope manifest for scope: ${scopeName}`);
+                    }
+                    else if (fullManifest.tables) {
+                        // Old-style single-scope manifest without scope field - assume it's for this scope
+                        fullManifest.scope = scopeName;
+                        ConfigManager.updateManifest(fullManifest);
+                        Logger_1.logger.debug(`Loaded manifest for scope: ${scopeName} (legacy format)`);
+                    }
+                    else {
+                        Logger_1.logger.warn(`[${scopeName}] Scope not found in manifest`);
+                    }
+                }
+                else {
+                    Logger_1.logger.warn(`[${scopeName}] No manifest found at ${scopeManifestPath} or ${manifestPath}`);
+                }
+            }
+            catch (error) {
+                Logger_1.logger.error(`Failed to load manifest for scope ${scopeName}: ${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 { 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();
                 // Get the scope ID
                 const scopeResponse = await unwrapSNResponse(client.getScopeId(scopeName));
@@ -204,7 +262,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
         }
         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 { defaultClient, unwrapSNResponse } = 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();
                 const config = ConfigManager.getConfig();
                 if (!config.scopes)
@@ -259,10 +317,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
         }
         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 { defaultClient } = await (__syncRequire ? Promise.resolve().then(() => __importStar(require("./snClient"))) : new Promise((resolve_4, reject_4) => { require(["./snClient"], resolve_4, reject_4); }).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 axios = (await (__syncRequire ? Promise.resolve().then(() => __importStar(require("axios"))) : new Promise((resolve_5, reject_5) => { require(["axios"], resolve_5, reject_5); }).then(__importStar))).default;
                 const { SN_USER = "", SN_PASSWORD = "", SN_INSTANCE = "" } = process.env;
                 const axiosClient = axios.create({
                     auth: {

package/dist/allScopesCommands.js

@@ -253,16 +253,19 @@ var __importStar = (this && this.__importStar) || (function () {
                     Logger_1.logger.error(`Failed to process ${scopeName}: ${(error === null || error === void 0 ? void 0 : error.message) || "Unknown error"}`);
                 }
             });
-            // Write the combined manifest file with the new structure
-            const manifestPath = path.join(ConfigManager.getRootDir(), "sinc.manifest.json");
-            await fsp.writeFile(manifestPath, JSON.stringify(manifests, null, 2));
+            // Write per-scope manifest files instead of a single combined one
+            for (const [scopeName, scopeData] of Object.entries(manifests)) {
+                const scopeManifestPath = ConfigManager.getScopeManifestPath(scopeName);
+                await fsp.writeFile(scopeManifestPath, JSON.stringify(scopeData, null, 2));
+                Logger_1.logger.info(`Wrote manifest for ${scopeName} to: ${scopeManifestPath}`);
+            }
             Logger_1.logger.info("=".repeat(50));
             Logger_1.logger.success(`✅ Scope initialization complete!`);
             Logger_1.logger.info(`Successfully processed: ${successCount} scopes`);
             if (failCount > 0) {
                 Logger_1.logger.warn(`Failed to process: ${failCount} scopes`);
             }
-            Logger_1.logger.info(`Manifest written to: ${manifestPath}`);
+            Logger_1.logger.info(`Manifests written as per-scope files (sinc.manifest.<scope>.json)`);
             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 watchAllScopes' to start development mode!");
         }

package/dist/appUtils.js

@@ -57,11 +57,29 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     const genericUtils_1 = require("./genericUtils");
     const processFilesInManRec = async (recPath, rec, forceWrite) => {
         const fileWrite = fUtils.writeSNFileCurry(forceWrite);
-        const filePromises = rec.files.map((file) => fileWrite(file, recPath));
-        await Promise.all(filePromises);
-        // Side effect, remove content from files so it doesn't get written to manifest
+        // Process metadata files separately
+        const metadataFiles = [];
+        const regularFiles = [];
         rec.files.forEach((file) => {
-            delete file.content;
+            if (file.name === "metaData" && file.type === "json") {
+                metadataFiles.push(file);
+            }
+            else {
+                regularFiles.push(file);
+            }
+        });
+        // Write metadata files with updated _lastUpdatedOn field
+        const metadataPromises = metadataFiles.map(async (file) => {
+            return fileWrite(file, recPath);
+        });
+        // Write regular files
+        const regularPromises = regularFiles.map((file) => fileWrite(file, recPath));
+        await Promise.all([...metadataPromises, ...regularPromises]);
+        // Remove content from ALL files and exclude metadata from manifest
+        rec.files = regularFiles.map((file) => {
+            const fileCopy = { ...file };
+            delete fileCopy.content;
+            return fileCopy;
         });
     };
     const processRecsInManTable = async (tablePath, table, forceWrite) => {
@@ -89,23 +107,50 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     };
     const processManifest = async (manifest, forceWrite = false) => {
         await processTablesInManifest(manifest.tables, forceWrite);
-        await fUtils.writeFileForce(ConfigManager.getManifestPath(), JSON.stringify(manifest, null, 2));
+        // Write to scope-specific manifest if scope is available
+        if (manifest.scope) {
+            await fUtils.writeScopeManifest(manifest.scope, manifest);
+        }
+        else {
+            // Fall back to legacy single manifest
+            await fUtils.writeFileForce(ConfigManager.getManifestPath(), JSON.stringify(manifest, null, 2));
+        }
     };
     exports.processManifest = processManifest;
-    const syncManifest = async () => {
+    const syncManifest = async (scope) => {
         try {
             const curManifest = await ConfigManager.getManifest();
             if (!curManifest)
                 throw new Error("No manifest file loaded!");
-            Logger_1.logger.info("Downloading fresh manifest...");
-            const client = (0, snClient_1.defaultClient)();
-            const config = ConfigManager.getConfig();
-            const newManifest = await (0, snClient_1.unwrapSNResponse)(client.getManifest(curManifest.scope, config));
-            Logger_1.logger.info("Writing new manifest file...");
-            fUtils.writeManifestFile(newManifest);
-            Logger_1.logger.info("Finding and creating missing files...");
-            await (0, exports.processMissingFiles)(newManifest);
-            ConfigManager.updateManifest(newManifest);
+            // If a specific scope is provided, sync only that scope
+            if (scope) {
+                Logger_1.logger.info(`Downloading fresh manifest for scope: ${scope}...`);
+                const client = (0, snClient_1.defaultClient)();
+                const config = ConfigManager.getConfig();
+                const newManifest = await (0, snClient_1.unwrapSNResponse)(client.getManifest(scope, config));
+                Logger_1.logger.info(`Writing manifest file for scope: ${scope}...`);
+                await fUtils.writeScopeManifest(scope, newManifest);
+                Logger_1.logger.info("Finding and creating missing files...");
+                await (0, exports.processMissingFiles)(newManifest);
+                // Update the in-memory manifest for this scope
+                if (typeof curManifest === "object" && !curManifest.tables) {
+                    curManifest[scope] = newManifest;
+                    ConfigManager.updateManifest(curManifest);
+                }
+            }
+            else {
+                // Sync all scopes if manifest has multiple scopes
+                if (typeof curManifest === "object" && !curManifest.tables) {
+                    // Multiple scopes detected
+                    for (const scopeName of Object.keys(curManifest)) {
+                        await (0, exports.syncManifest)(scopeName);
+                    }
+                }
+                else if (curManifest.scope) {
+                    // Single scope manifest
+                    await (0, exports.syncManifest)(curManifest.scope);
+                }
+            }
         }
         catch (e) {
             let message;

package/dist/config.js

@@ -53,6 +53,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     exports.getRootDir = getRootDir;
     exports.getManifest = getManifest;
     exports.getManifestPath = getManifestPath;
+    exports.getScopeManifestPath = getScopeManifestPath;
     exports.getSourcePath = getSourcePath;
     exports.getBuildPath = getBuildPath;
     exports.getEnvPath = getEnvPath;
@@ -60,6 +61,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     exports.getDiffFile = getDiffFile;
     exports.getRefresh = getRefresh;
     exports.getDefaultConfigFile = getDefaultConfigFile;
+    exports.loadScopeManifest = loadScopeManifest;
     exports.updateManifest = updateManifest;
     const path_1 = __importDefault(require("path"));
     const fs_1 = require("fs");
@@ -138,11 +140,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
         if (!setup)
             throw new Error("Error getting manifest");
     }
-    function getManifestPath() {
+    function getManifestPath(scope) {
+        if (scope) {
+            const rootDir = getRootDir();
+            return path_1.default.join(rootDir, `sinc.manifest.${scope}.json`);
+        }
         if (manifest_path)
             return manifest_path;
         throw new Error("Error getting manifest path");
     }
+    function getScopeManifestPath(scope) {
+        const rootDir = getRootDir();
+        return path_1.default.join(rootDir, `sinc.manifest.${scope}.json`);
+    }
     function getSourcePath() {
         if (source_path)
             return source_path;
@@ -221,11 +231,58 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     }
     async function loadManifest() {
         try {
+            // Try to load legacy single manifest first
             let manifestString = await fs_1.promises.readFile(getManifestPath(), "utf-8");
             manifest = JSON.parse(manifestString);
         }
         catch (e) {
-            manifest = undefined;
+            // If no single manifest, try to load all scope-specific manifests
+            manifest = await loadAllScopeManifests();
+        }
+    }
+    async function loadAllScopeManifests() {
+        try {
+            const rootDir = getRootDir();
+            const files = await fs_1.promises.readdir(rootDir);
+            const manifestFiles = files.filter(f => f.startsWith('sinc.manifest.') && f.endsWith('.json') && f !== 'sinc.manifest.json');
+            if (manifestFiles.length === 0) {
+                return undefined;
+            }
+            // Combine all scope manifests into a single structure for backward compatibility
+            const combinedManifest = {};
+            for (const file of manifestFiles) {
+                const scope = file.replace('sinc.manifest.', '').replace('.json', '');
+                const manifestPath = path_1.default.join(rootDir, file);
+                try {
+                    const content = await fs_1.promises.readFile(manifestPath, "utf-8");
+                    const scopeManifest = JSON.parse(content);
+                    // If the manifest already has the scope at root level, use it directly
+                    if (scopeManifest.scope && scopeManifest.tables) {
+                        combinedManifest[scope] = scopeManifest;
+                    }
+                    else {
+                        // Otherwise wrap it
+                        combinedManifest[scope] = scopeManifest;
+                    }
+                }
+                catch (e) {
+                    Logger_1.logger.warn(`Failed to load manifest for scope ${scope}: ${e}`);
+                }
+            }
+            return Object.keys(combinedManifest).length > 0 ? combinedManifest : undefined;
+        }
+        catch (e) {
+            return undefined;
+        }
+    }
+    async function loadScopeManifest(scope) {
+        try {
+            const manifestPath = getScopeManifestPath(scope);
+            const content = await fs_1.promises.readFile(manifestPath, "utf-8");
+            return JSON.parse(content);
+        }
+        catch (e) {
+            return undefined;
         }
     }
     function updateManifest(man) {

package/package.json

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