@tenonhq/dovetail-core 0.0.85

package/dist/PluginManager.js

@@ -0,0 +1,125 @@
+"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 });
+const ConfigManager = __importStar(require("./config"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const fsp = fs_1.default.promises;
+class PluginManager {
+    pluginRules;
+    constructor() {
+        this.pluginRules = [];
+    }
+    async loadPluginConfig() {
+        let conf = ConfigManager.getConfig();
+        if (conf && conf.rules) {
+            this.pluginRules = conf.rules;
+        }
+    }
+    determinePlugins(context) {
+        let plugins = [];
+        for (let rule of this.pluginRules) {
+            let reg = rule.match;
+            if (reg.test(context.filePath)) {
+                plugins = rule.plugins;
+                //only match first rule
+                break;
+            }
+        }
+        return plugins;
+    }
+    async runPlugins(plugins, context, content) {
+        try {
+            let output = content;
+            for (let pConfig of plugins) {
+                let pluginPath = path_1.default.join(ConfigManager.getRootDir(), "node_modules", pConfig.name);
+                let plugin = await Promise.resolve(`${pluginPath}`).then(s => __importStar(require(s)));
+                let results = await plugin.run(context, output, pConfig.options);
+                if (!results.success) {
+                    return {
+                        success: false,
+                        content: "",
+                    };
+                }
+                output = results.output;
+            }
+            return {
+                success: true,
+                content: output,
+            };
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async processFile(context, content) {
+        const plugins = this.determinePlugins(context);
+        if (plugins.length > 0) {
+            try {
+                const pluginResults = await this.runPlugins(plugins, context, content);
+                if (pluginResults.success) {
+                    return pluginResults.content;
+                }
+                else {
+                    throw new Error(`Failed to build ${context.tableName}=>${context.sys_id}!`);
+                }
+            }
+            catch (e) {
+                throw e;
+            }
+        }
+        else {
+            return content;
+        }
+    }
+    async getFinalFileContents(context, processFile = true) {
+        const { filePath } = context;
+        try {
+            const contents = await fsp.readFile(filePath, "utf-8");
+            if (processFile) {
+                await this.loadPluginConfig();
+                return await this.processFile(context, contents);
+            }
+            return contents;
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+}
+exports.default = new PluginManager();

package/dist/_defaultOptionsOLD.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tableOptions = exports.scopes = exports.includes = exports.excludes = void 0;
+let excludes = {
+    sys_scope_privilege: true,
+    sys_dictionary: true,
+    sys_impex_entry: true,
+    sys_security_acl: true,
+    sys_transform_map: true,
+    sys_ui_policy: true,
+    sys_ui_list_control: true,
+    sys_relationship: true,
+    sys_report: true,
+    item_option_new: true,
+    sys_process_flow: true,
+    content_block_programmatic: true,
+    sp_instance: true,
+    sys_transform_script: true,
+    sc_category: true,
+    sysrule_view: true,
+    sc_cat_item: true,
+    sysevent_in_email_action: true,
+    sys_navigator: true,
+    sys_transform_entry: true,
+    metric_definition: true,
+    content_block_lists: true,
+    content_block_detail: true,
+    sp_portal: true,
+    sc_cat_item_producer: true,
+    sys_impex_map: true,
+};
+exports.excludes = excludes;
+let includes = {
+    content_css: {
+        style: {
+            type: "css",
+        },
+    },
+};
+exports.includes = includes;
+let tableOptions = {};
+exports.tableOptions = tableOptions;
+let scopes = {};
+exports.scopes = scopes;

package/dist/allScopesCommands.js

@@ -0,0 +1,418 @@
+"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 });
+exports.processScope = processScope;
+exports.initScopesCommand = initScopesCommand;
+exports.watchAllScopesCommand = watchAllScopesCommand;
+const Logger_1 = require("./Logger");
+const FileLogger_1 = require("./FileLogger");
+const ConfigManager = __importStar(require("./config"));
+const AppUtils = __importStar(require("./appUtils"));
+const wizard_1 = require("./wizard");
+const snClient_1 = require("./snClient");
+const commands_1 = require("./commands");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const child_process_1 = require("child_process");
+const progress_1 = __importDefault(require("progress"));
+const fsp = fs.promises;
+// Custom function to process manifest with specific source directory
+async function processManifestForScope(manifest, sourceDirectory, forceWrite = false) {
+    try {
+        // Ensure the source directory exists
+        try {
+            await fsp.mkdir(sourceDirectory, { recursive: true });
+        }
+        catch (dirError) {
+            Logger_1.logger.error("Failed to create directory: " + sourceDirectory);
+            throw dirError;
+        }
+        const tables = manifest.tables || {};
+        const tableNames = Object.keys(tables);
+        var totalRecords = 0;
+        for (var tn = 0; tn < tableNames.length; tn++) {
+            totalRecords += Object.keys(tables[tableNames[tn]].records || {}).length;
+        }
+        var scopeLabel = sourceDirectory.split(path.sep).pop() || "scope";
+        var progBar = null;
+        if (Logger_1.logger.getLogLevel() === "info" && totalRecords > 0) {
+            progBar = new progress_1.default(":scope :bar :current/:total (:percent)", {
+                total: totalRecords,
+                width: 40,
+                complete: "=",
+                incomplete: "-",
+            });
+        }
+        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 || {});
+            FileLogger_1.fileLogger.debug("Table " + tableName + ": " + recordNames.length + " records");
+            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);
+                // Check if metadata file exists in the files from server
+                const hasMetadataFromServer = record.files && record.files.some((f) => f.name === 'metaData' && f.type === 'json');
+                // 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 || "";
+                    const fileDir = path.dirname(filePath);
+                    await fsp.mkdir(fileDir, { recursive: true });
+                    try {
+                        await fsp.writeFile(filePath, fileContent, "utf8");
+                    }
+                    catch (writeError) {
+                        Logger_1.logger.error("Failed to write: " + filePath);
+                        throw writeError;
+                    }
+                }
+                // If no metadata from server, create a basic one
+                if (!hasMetadataFromServer) {
+                    const metadataFilePath = path.join(recordPath, "metaData.json");
+                    const metadataContent = {
+                        _generatedAt: new Date().toISOString(),
+                        _note: "Generated locally - metadata not provided by server"
+                    };
+                    try {
+                        await fsp.writeFile(metadataFilePath, JSON.stringify(metadataContent, null, 2), "utf8");
+                    }
+                    catch (metaError) {
+                        Logger_1.logger.error("Failed to write metadata: " + metadataFilePath);
+                    }
+                }
+                if (progBar)
+                    progBar.tick({ scope: scopeLabel });
+            }
+        }
+    }
+    catch (error) {
+        Logger_1.logger.error("Error processing files for " + sourceDirectory + ": " + error);
+        throw error;
+    }
+}
+async function processScope(scopeName, scopeConfig, apiDelay = 0) {
+    try {
+        const instance = process.env.SN_INSTANCE || "unknown";
+        Logger_1.logger.info("Processing scope: " + scopeName + " (" + instance + ")");
+        // Get the client
+        const client = (0, snClient_1.defaultClient)();
+        // Get the config
+        const config = ConfigManager.getConfig();
+        // Determine the source directory for this scope
+        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);
+        }
+        FileLogger_1.fileLogger.debug("Source directory for " + scopeName + ": " + sourceDirectory);
+        const apps = await (0, snClient_1.unwrapSNResponse)(client.getAppList());
+        const scopeApp = apps.find((app) => app.scope === scopeName);
+        if (!scopeApp) {
+            Logger_1.logger.warn("Scope " + scopeName + " not found in ServiceNow apps list");
+        }
+        else {
+            Logger_1.logger.info("Found app: " + scopeApp.displayName);
+        }
+        // Resolve the table whitelist and field overrides for this scope
+        var resolvedConfig = ConfigManager.resolveConfigForScope(scopeName);
+        var allowedTables = resolvedConfig.tables;
+        // Build a config safe for the ServiceNow API (no _ directive keys)
+        var apiConfig = Object.assign({}, config, {
+            includes: resolvedConfig.apiIncludes,
+            excludes: resolvedConfig.apiExcludes,
+        });
+        Logger_1.logger.info("Downloading manifest for " + scopeName + "...");
+        if (apiDelay > 0) {
+            await delay(apiDelay);
+        }
+        const manifest = await (0, snClient_1.unwrapSNResponse)(client.getManifest(scopeName, apiConfig, false));
+        // Client-side table filtering — only keep tables in the _tables whitelist
+        if (allowedTables && allowedTables.length > 0) {
+            var manifestTableNames = Object.keys(manifest.tables || {});
+            var filteredTables = {};
+            var skippedCount = 0;
+            for (var t = 0; t < manifestTableNames.length; t++) {
+                var tName = manifestTableNames[t];
+                if (allowedTables.indexOf(tName) !== -1) {
+                    filteredTables[tName] = manifest.tables[tName];
+                }
+                else {
+                    skippedCount++;
+                }
+            }
+            var keptCount = Object.keys(filteredTables).length;
+            if (skippedCount > 0) {
+                FileLogger_1.fileLogger.debug("Filtered " + skippedCount + " tables not in _tables whitelist for " + scopeName +
+                    ". Keeping " + keptCount + " of " + manifestTableNames.length);
+            }
+            Logger_1.logger.info(scopeName + ": " + keptCount + " tables match config (" + skippedCount + " filtered out)");
+            manifest.tables = filteredTables;
+        }
+        else {
+            Logger_1.logger.warn("No _tables whitelist defined — writing ALL tables for " + scopeName);
+        }
+        // Normalize record keys from sys_id to display name
+        AppUtils.normalizeManifestKeys(manifest);
+        // Build the missing files structure from the filtered manifest
+        var manifestTables = manifest.tables || {};
+        var allMissingFiles = {};
+        for (var tableName in manifestTables) {
+            var table = manifestTables[tableName];
+            allMissingFiles[tableName] = {};
+            for (var recordName in table.records || {}) {
+                var record = table.records[recordName];
+                allMissingFiles[tableName][record.sys_id] = record.files.map(function (f) {
+                    return { name: f.name, type: f.type };
+                });
+            }
+        }
+        // Download file contents in chunks to avoid ServiceNow 500 errors on large payloads
+        var CHUNK_SIZE = 5;
+        var tableNames = Object.keys(allMissingFiles);
+        var totalChunks = Math.ceil(tableNames.length / CHUNK_SIZE);
+        Logger_1.logger.info("Downloading file contents for " + scopeName + " (" + tableNames.length + " tables in " + totalChunks + " batch" + (totalChunks !== 1 ? "es" : "") + ")...");
+        for (var chunkIdx = 0; chunkIdx < tableNames.length; chunkIdx += CHUNK_SIZE) {
+            var chunkTableNames = tableNames.slice(chunkIdx, chunkIdx + CHUNK_SIZE);
+            var chunkMissing = {};
+            for (var ci = 0; ci < chunkTableNames.length; ci++) {
+                chunkMissing[chunkTableNames[ci]] = allMissingFiles[chunkTableNames[ci]];
+            }
+            if (apiDelay > 0) {
+                await delay(apiDelay);
+            }
+            var batchNum = Math.floor(chunkIdx / CHUNK_SIZE) + 1;
+            FileLogger_1.fileLogger.debug("Downloading batch " + batchNum + "/" + totalChunks + " for " + scopeName + ": " + chunkTableNames.join(", "));
+            var chunkContent = await (0, snClient_1.unwrapSNResponse)(client.getMissingFiles(chunkMissing, config.tableOptions || {}));
+            // Merge chunk content back into the manifest
+            for (var chunkTable in chunkContent || {}) {
+                if (manifest.tables[chunkTable]) {
+                    for (var chunkRecName in chunkContent[chunkTable].records || {}) {
+                        var recordWithContent = chunkContent[chunkTable].records[chunkRecName];
+                        var manifestRecords = manifest.tables[chunkTable].records;
+                        var matchingRecord = Object.values(manifestRecords).find(function (r) {
+                            return r.sys_id === recordWithContent.sys_id;
+                        });
+                        if (matchingRecord) {
+                            matchingRecord.files = recordWithContent.files;
+                        }
+                    }
+                }
+            }
+        }
+        const tableCount = Object.keys((manifest && manifest.tables) || {}).length;
+        Logger_1.logger.info("Writing " + tableCount + " tables for " + scopeName + "...");
+        await processManifestForScope(manifest, sourceDirectory, true);
+        // Create the scope-specific manifest structure
+        const scopeManifest = {
+            tables: (manifest && manifest.tables) || {},
+            scope: scopeName,
+        };
+        Logger_1.logger.success("Scope " + scopeName + " complete — files saved to " + sourceDirectory);
+        return {
+            scope: scopeName,
+            success: true,
+            manifest: scopeManifest,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        Logger_1.logger.error("Failed to process scope " + scopeName + ": " + errorMessage);
+        return {
+            scope: scopeName,
+            success: false,
+            error: error instanceof Error ? error : new Error(String(error)),
+        };
+    }
+}
+// Helper function to add delay between API calls
+async function delay(ms) {
+    if (ms > 0) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+}
+async function initScopesCommand(args) {
+    (0, commands_1.setLogLevel)(args);
+    // Get API delay from args, default to 0ms (no delay)
+    const apiDelay = args.delay || 0;
+    if (apiDelay > 0) {
+        Logger_1.logger.info(`Using ${apiDelay}ms delay between API calls to prevent server overload`);
+    }
+    try {
+        // First check if we have environment variables set
+        if (!process.env.SN_USER ||
+            !process.env.SN_PASSWORD ||
+            !process.env.SN_INSTANCE) {
+            try {
+                let loginAnswers = await (0, wizard_1.getLoginInfo)();
+                await (0, wizard_1.setupDotEnv)(loginAnswers);
+            }
+            catch (error) {
+                Logger_1.logger.error("Error getting ServiceNow credentials: " + error);
+                throw error;
+            }
+            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");
+            }
+        }
+        // Load config
+        await ConfigManager.loadConfigs();
+        const config = ConfigManager.getConfig();
+        if (!config.scopes) {
+            Logger_1.logger.error("No scopes defined in dove.config.js");
+            throw new Error("No scopes defined in configuration");
+        }
+        const scopes = Object.keys(config.scopes);
+        const instance = process.env.SN_INSTANCE || "unknown";
+        Logger_1.logger.info("Initializing " + scopes.length + " scopes from " + instance + ": " + scopes.join(", "));
+        const scopePromises = scopes.map((scopeName) => processScope(scopeName, config.scopes[scopeName], apiDelay));
+        const results = await Promise.allSettled(scopePromises);
+        // Collect successful manifests
+        const manifests = {};
+        let successCount = 0;
+        let failCount = 0;
+        results.forEach((result, index) => {
+            const scopeName = scopes[index];
+            if (result.status === "fulfilled" && result.value.success) {
+                manifests[scopeName] = result.value.manifest;
+                successCount++;
+            }
+            else {
+                failCount++;
+                const error = result.status === "rejected" ? result.reason : (result.value && result.value.error);
+                Logger_1.logger.error(`Failed to process ${scopeName}: ${(error && error.message) || "Unknown error"}`);
+            }
+        });
+        // 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 — " + successCount + "/" + scopes.length + " scopes processed");
+        if (failCount > 0) {
+            Logger_1.logger.warn(failCount + " scope(s) failed — check errors above");
+        }
+        Logger_1.logger.info("Manifests: dove.manifest.<scope>.json");
+        Logger_1.logger.success("Run 'npx dove watch' to start development");
+    }
+    catch (e) {
+        Logger_1.logger.error("Error initializing scopes: " + e);
+        throw e;
+    }
+}
+async function watchAllScopesCommand(args) {
+    (0, commands_1.setLogLevel)(args);
+    var dashboardProcess = null;
+    try {
+        // First check if we have environment variables set
+        if (!process.env.SN_USER ||
+            !process.env.SN_PASSWORD ||
+            !process.env.SN_INSTANCE) {
+            let loginAnswers = await (0, wizard_1.getLoginInfo)();
+            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");
+        }
+        // Start dashboard unless --no-dashboard flag is set
+        if (!args.noDashboard) {
+            dashboardProcess = startDashboardProcess(args.port);
+        }
+        // Import and start the multi-scope watcher
+        const { startMultiScopeWatching } = await Promise.resolve().then(() => __importStar(require("./MultiScopeWatcher")));
+        // Start watching all scopes with monitoring options
+        await startMultiScopeWatching({
+            monitorIntervalMs: args.noMonitoring ? 0 : (args.monitorInterval || 120) * 1000,
+        });
+        // Keep the process running
+        process.on("SIGINT", async () => {
+            Logger_1.logger.info("\nStopping multi-scope watch...");
+            if (dashboardProcess) {
+                dashboardProcess.kill("SIGINT");
+            }
+            const { stopMultiScopeWatching } = await Promise.resolve().then(() => __importStar(require("./MultiScopeWatcher")));
+            stopMultiScopeWatching();
+            process.exit(0);
+        });
+    }
+    catch (error) {
+        if (dashboardProcess) {
+            dashboardProcess.kill("SIGINT");
+        }
+        Logger_1.logger.error("Failed to start multi-scope watch: " + error);
+        throw error;
+    }
+}
+function startDashboardProcess(portOverride) {
+    var serverPath;
+    try {
+        serverPath = require.resolve("@tenonhq/dovetail-dashboard/server.js");
+    }
+    catch (e) {
+        Logger_1.logger.warn("Dashboard package not installed. Run: npm install @tenonhq/dovetail-dashboard");
+        return null;
+    }
+    var port = portOverride ? String(portOverride) : (process.env.DASHBOARD_PORT || "3456");
+    var server = (0, child_process_1.spawn)("node", [serverPath], {
+        cwd: process.cwd(),
+        stdio: "ignore",
+        env: { ...process.env, DASHBOARD_PORT: port },
+        detached: false,
+    });
+    server.on("error", function (err) {
+        Logger_1.logger.warn("Failed to start dashboard: " + err.message);
+    });
+    Logger_1.logger.info("Dashboard started at http://localhost:" + port);
+    // Open browser after a short delay
+    setTimeout(function () {
+        var url = "http://localhost:" + port;
+        (0, child_process_1.spawn)("open", [url], { stdio: "ignore" });
+    }, 1000);
+    return server;
+}