@tenonhq/sincronia-core 0.0.39 → 0.0.40

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

@@ -170,9 +170,22 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
                 // 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
-                // Try to load the manifest (could be single-scope or multi-scope)
-                const manifestPath = path.join(projectRoot, "sinc.manifest.json");
                 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);
@@ -183,7 +196,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
                         // Add the scope field for compatibility
                         scopeManifest.scope = scopeName;
                         ConfigManager.updateManifest(scopeManifest);
-                        Logger_1.logger.debug(`Loaded manifest for scope: ${scopeName} from multi-scope manifest`);
+                        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
@@ -201,7 +214,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
                     }
                 }
                 else {
-                    Logger_1.logger.warn(`[${scopeName}] No manifest found at ${manifestPath}`);
+                    Logger_1.logger.warn(`[${scopeName}] No manifest found at ${scopeManifestPath} or ${manifestPath}`);
                 }
             }
             catch (error) {

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,43 @@ 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 _generatedAt field
+        const metadataPromises = metadataFiles.map(async (file) => {
+            if (file.content) {
+                try {
+                    const metadata = JSON.parse(file.content);
+                    // Update _generatedAt with sys_updated_on value if it exists
+                    if (metadata.sys_updated_on && metadata.sys_updated_on.value) {
+                        metadata._generatedAt = metadata.sys_updated_on.value;
+                    }
+                    // Write the updated metadata
+                    file.content = JSON.stringify(metadata, null, 2);
+                }
+                catch (e) {
+                    // If parsing fails, just write as-is
+                }
+            }
+            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 +121,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.39",
+  "version": "0.0.40",
   "description": "Next-gen file syncer",
   "license": "GPL-3.0",
   "main": "./dist/index.js",