cob-cli 2.49.0 → 2.50.0

package/lib/task_lists/common_helpers.js

@@ -1,3 +1,8 @@
+const inquirer = require("inquirer")
+const readline = require('readline');
+const yaml = require('js-yaml');
+const fs = require("fs/promises");
+
 const SERVER_COB_CLI_DIRECTORY = "/opt/cob-cli/";
 
 /* **************************************************************************************** */
@@ -41,25 +46,64 @@ function checkConnectivity(server) {
     ])
 }
 
+
 /* ************************************ */
+let readlineSetup = false
 function getKeypress() {
-    const readline = require('readline');
-
+    if (!readlineSetup) {
+        readline.emitKeypressEvents(process.stdin);
+        readlineSetup = true
+    }
     process.stdin.setRawMode(true);
-    readline.emitKeypressEvents(process.stdin);
     const rl = readline.createInterface({
         input: process.stdin
     });
-    return new Promise(resolve => rl.input.on("keypress", (letter,key) => {
-        if(key.name == "return") {
-            console.log("")
-        } else {
-            if(key.ctrl && key.name == 'c') letter = "ctrl+c"
-            rl.close();
-            process.stdin.setRawMode(false);
-            resolve(letter && letter.toLowerCase() || key.name);
+   
+    return new Promise(resolve => {
+        const listener = function(letter,key){
+            if(key.name == "return") {
+                console.log("")
+
+            } else {
+                if(key.ctrl && key.name == 'c') letter = "ctrl+c"
+                rl.input.removeListener('keypress', listener)
+                rl.close();
+                process.stdin.setRawMode(false);
+                resolve(letter && letter.toLowerCase() || key.name);
+            }
         }
-    }))
+        rl.input.on("keypress", listener)
+    })
+}
+
+/* ************************************ */
+async function promptCredentials() {
+    const answers = await inquirer.prompt([
+        {
+            type: 'text',
+            message: 'Enter username:',
+            name: 'username',
+        },
+        {
+            type: 'password',
+            message: 'Enter password:',
+            name: 'password',
+            mask: '*',
+        },
+    ])
+
+    return answers
+};
+
+/* ************************************ */
+async function readYamlFile(filename) {
+    try {
+        const data = await fs.readFile(filename, 'utf-8');
+        const config = yaml.load(data);
+        return config
+    } catch (error) {
+        console.error('Error reading YAML file:', error.message);
+    }
 }
 
 /* ************************************ */
@@ -67,5 +111,7 @@ module.exports = {
     SERVER_COB_CLI_DIRECTORY : SERVER_COB_CLI_DIRECTORY,
     checkConnectivity: checkConnectivity,
     checkWorkingCopyCleanliness: checkWorkingCopyCleanliness,
-    getKeypress: getKeypress
+    getKeypress: getKeypress,
+    promptCredentials: promptCredentials,
+    readYamlFile: readYamlFile
 };

package/lib/task_lists/common_operationState.js

@@ -0,0 +1,28 @@
+const fs = require('fs-extra');
+const fg = require('fast-glob');
+const STATE_FILE = ".git/cob-cli-state";
+
+function saveOperationState(environment, servername) {
+    try { fs.writeJsonSync(STATE_FILE, { environment, servername }); } catch {}
+}
+
+function loadOperationState() {
+    try { return fs.readJsonSync(STATE_FILE); } catch { return null; }
+}
+
+function clearOperationState() {
+    try { fs.unlinkSync(STATE_FILE); } catch {}
+}
+
+async function checkNoInterruptedRun() {
+    const stateExists = !!loadOperationState();
+    const envBackupFiles = await fg(['**/*.ENV__ORIGINAL_BACKUP__.*', '**/*.ENV__DELETE__.*'], { onlyFiles: false, dot: true });
+    if (stateExists || envBackupFiles.length > 0) {
+        throw new Error(
+            "\nAborted:".red + " found traces of a previous interrupted test/deploy.\n"
+            + "Run " + "cob-cli cleanup".yellow + " to restore the repo to a clean state first.\n"
+        );
+    }
+}
+
+module.exports = { saveOperationState, loadOperationState, clearOperationState, checkNoInterruptedRun };

package/lib/task_lists/common_syncFiles.js

@@ -32,6 +32,7 @@ async function _syncFiles(executionType, cmdEnv, from, to, extraOptions = [], ar
         return new Promise(async (resolve, reject) => {
             let fromPath = resolveCobPath(cmdEnv.server, from, product);
             let toPath = resolveCobPath(cmdEnv.server, to, product);
+            if (toPath.startsWith('.') && !fs.existsSync(toPath)) fs.mkdirSync(toPath)
             let productExtraOptions = extraOptions.map( option => option.replace(/=.*\|/,"="))
             productExtraOptions = productExtraOptions.filter( option => option.indexOf("|") < 0 )
 
@@ -179,6 +180,9 @@ function resolveCobPath(server, type, product) {
                 default:
                     return server + ':' + "/etc/" + product + "/";
             }
+
+        case "staging":
+            return ".staging/" + product + "/";
     }
 }
 exports.resolveCobPath = resolveCobPath;

package/lib/task_lists/package_execute.js

@@ -0,0 +1,45 @@
+const Listr = require('listr');
+const UpdaterRenderer = require('listr-update-renderer');
+const verboseRenderer = require('listr-verbose-renderer');
+const { copyFiles } = require("./common_syncFiles");
+const fs = require("fs");
+const tar = require('tar');
+const { format } = require('date-fns');
+
+
+function executeTasks(cmdEnv, args) {
+    console.log("\nPackaging ...");
+
+    return new Listr([
+        {title: "Apply new enviroment specifics", task: () => cmdEnv.applyCurrentCommandEnvironmentChanges() },
+        {title: "Create staging dir",             task: () => fs.existsSync('.staging') || fs.mkdirSync('.staging') },
+        {title: "Copy files to staging dir",      task: () => copyFiles(cmdEnv, "localCopy", "staging")},
+        {title: "Create package",                 task: async () => { const filename = await createPackage(cmdEnv, args); console.log("created " + filename) }},
+        {title: "Sign package",                   task: () => console.log("lololo")},
+        {title: "Delete staging dir",             task: () => fs.rmSync('.staging', {recursive: true, force: true})},
+        {title: "Undo new enviroment specifics",  task: () => cmdEnv.unApplyCurrentCommandEnvironmentChanges() },
+    ], {
+        renderer: args.verbose ? verboseRenderer : UpdaterRenderer,
+        collapse: false
+    });
+}
+exports.executeTasks = executeTasks;
+
+const createPackage = async function(cmdEnv, args){
+   const filename = `${cmdEnv.servername}-${cmdEnv.name}-${format(new Date(), 'yyyy-MM-dd_HH_mm')}.tar.gz`; 
+   const files = fs.readdirSync('.staging')
+   if (args.verbose > 0){
+      console.log("packaging " + files)
+   }
+
+    await tar.create({
+        gzip: true,
+        file: filename,
+        cwd: '.staging',
+        onWriteEntry(entry) {
+            if (args.verbose > 2) console.log('adding', entry.path, entry.stat.mode.toString(8))
+        }
+    }, files)
+
+   return filename;
+}

package/lib/task_lists/tagDefs_execute.js

@@ -0,0 +1,121 @@
+require('colors');
+const Listr = require('listr');
+const UpdaterRenderer = require('listr-update-renderer');
+const VerboseRenderer = require('listr-verbose-renderer');
+const { getFilteredDefinitions } = require('./common_definitions.js')
+const axios = require("axios");
+const inquirer = require("inquirer")
+
+async function getUntaggedChanges(servername, defId) {
+    const uri = `https://${servername}.cultofbits.com/recordm/recordm/definitions/${defId}/changes?tagged=false`
+
+    const response = await axios.get(uri, {params: {tagged: false}});
+
+    if(response.status % 200 > 100){
+        throw new Error(`HTTP Error Response: ${response.status} ${response.statusText}`);
+    }
+
+    return ( response.data || []).filter(c => !c.tag)
+}
+
+async function tagDefinition(servername, defId, until) {
+    const uri = `https://${servername}.cultofbits.com/recordm/recordm/definitions/${defId}/tag`
+
+    const params = {}
+    if(until) {
+        params.until = until
+    }
+   
+    const response = await axios.put(uri, "", {headers: {'Content-Type': 'application/json'}, params: params});
+
+    if(response.status != 200){
+        throw new Error(`HTTP Error Response: ${response.status} ${response.statusText}`);
+    }
+
+    return response.data
+}
+
+async function tagDefinitions(servername, customization, defs, args) {
+    return new Listr([
+        {
+            title: `(${customization}) Definitions: `.bold + "searching for definitions matching queries",
+            task: async ctx => ctx.defs = (await getFilteredDefinitions(servername, defs))
+            .map(d => ({id: d.id, name: d.name}))
+        },
+        {
+            title: `(${customization}) Definitions: `.bold + "enriching metadata",
+            task: async ctx => {
+                for (const def of ctx.defs){
+                    def.changes = await getUntaggedChanges(servername, def.id)
+                    if(args.verbose) console.log(`definition ${def.name}: ${def.changes.length} untagged changes`)
+                }
+            }
+        },
+        {
+            title: `(${customization}) Definitions: `.bold + "tagging un-tagged changes",
+            task: async ctx => {
+                const subtasks = ctx.defs.map(d => ({
+                    title: "Tagging changes to " + d.name.bold,
+                    task: async (_, task) => {
+                        if (d.changes.length == 0) {
+                            task.skip("no untagged changes")
+                            return
+                        }
+
+                        if(args.all) {
+                            await tagDefinition(servername, d.id)
+                            task.output = 'Tagged by all'
+                            return
+                        }
+
+                        d.changes.forEach(c => console.log(JSON.stringify(c)))
+
+                        const answer = await inquirer.prompt([
+                            {
+                                type: 'rawlist',
+                                name: 'action',
+                                message: `Do you wish to tag the ${d.changes.length} changes? (^c to abort)`,
+                                choices: [
+                                    'Tag Changes',
+                                    'Choose Changes',
+                                    'Skip',
+                                ]
+                            }
+                        ])
+                        if (answer.action == 'Skip') {
+                            task.skip()
+
+                        } else if (answer.action == 'Tag Changes') {
+                            await tagDefinition(servername, d.id)
+                            task.output = 'Tagged'
+
+                        } else if (answer.action == 'Choose Changes') {
+                           const dates = d.changes.reduce((acc, cur) => {
+                              if(!acc.includes(cur.date)) acc.push(cur.date)
+                              return acc
+                           }, [])
+                           const answerDate = await inquirer.prompt([
+                              {
+                                type: 'rawlist',
+                                name: 'date',
+                                message: `Choose the oldest date to tag`,
+                                choices: dates
+                              }
+                           ])
+                           await tagDefinition(servername, d.id, answerDate.date)
+                           task.output = 'Tagged until ' + answerDate.date
+                        }
+                    }
+                }))
+                return new Listr(subtasks)
+            }
+        },
+    ],{
+        // we need to list changes and read user input, the VerboseRenderer is needed
+        renderer: VerboseRenderer,
+        collapse: false
+    }).run()
+}
+
+
+exports.tagDefinitions = tagDefinitions

package/lib/task_lists/test_customUIsContinuosReload.js

@@ -1,11 +1,28 @@
 const execa = require('execa');
 const path = require('path');
+const net = require('net');
 const concurrently = require('concurrently');
 const fs= require('fs');
 const util  = require('util');
 const child_process = require('child_process');
 const exec = util.promisify(child_process.exec);
 
+function findPort(preferred = 8040) {
+    return new Promise((resolve) => {
+        const server = net.createServer();
+        server.listen(preferred, '0.0.0.0', () => {
+            server.close(() => resolve(preferred));
+        });
+        server.on('error', () => {
+            const fallback = net.createServer();
+            fallback.listen(0, '0.0.0.0', () => {
+                const port = fallback.address().port;
+                fallback.close(() => resolve(port));
+            });
+        });
+    });
+}
+
 
 async function customUIsContinuosReload(cmdEnv, dashboard) {
     process.env.dash_dir = dashboard
@@ -22,6 +39,9 @@ async function customUIsContinuosReload(cmdEnv, dashboard) {
         throw new Error("Aborted: ".red + " dashboard " + dashboard.bold + " does not exist.\n  ")
     }
 
+    const dashPort = await findPort(8041);
+    process.env.dash_port = dashPort;
+
     if(dashboardPathIsDirectory) {
         // If we have a dashboard to serve run it from local dashboard directory on 8081 with vue-cli-service
         // it will use its vue.config.js
@@ -31,13 +51,15 @@ async function customUIsContinuosReload(cmdEnv, dashboard) {
         commands.push( {
             command: [
                 "cd " + dashboardPath + ";",
-                "node_modules/.bin/vue-cli-service serve --port 8041 2>/dev/null" 
-            ].join(" "), 
+                "node_modules/.bin/vue-cli-service serve --port " + dashPort + " 2>/dev/null"
+            ].join(" "),
             name: 'dashboard server',
-            prefixColor: "red" 
+            prefixColor: "red"
         })
     }
 
+    const port = await findPort(8040);
+
     console.log( "\n" + (" NOTE: Press " + "O".bold.red + " to open default browser, " + "CTRL+C".bold.red + " or " + "Q".bold.red + " to stop the tests... ").yellow.bold + "\n\n" )
 
     const insideCobCliPath = path.resolve(__dirname, '../../node_modules/.bin/webpack-dev-server');
@@ -50,8 +72,9 @@ async function customUIsContinuosReload(cmdEnv, dashboard) {
             webpackDevServerPath,
             "--config",
             path.resolve(__dirname, "../webpack/webpack.config.js"),
-            "--mode=development"
-        ].join(" "), 
+            "--mode=development",
+            "--port", port
+        ].join(" "),
         name: 'customUIs server',
         prefixColor: "blue" 
     }) 
@@ -82,14 +105,20 @@ async function customUIsContinuosReload(cmdEnv, dashboard) {
         }
     }
 
-    conc.result.catch( _err => { 
+    let notifyFailure;
+    const failurePromise = new Promise((_, reject) => { notifyFailure = reject; });
+
+    conc.result.catch( _err => {
         if(isStopping) return;
 
         stopEverything();
+        notifyFailure(new Error('processes-failed'));
     });
 
     return {
-        stop: stopEverything
+        stop: stopEverything,
+        failed: failurePromise,
+        port
     };
 }
 exports.customUIsContinuosReload = customUIsContinuosReload;

package/lib/task_lists/test_otherFilesContiousReload.js

@@ -29,22 +29,7 @@ async function otherFilesContiousReload(cmdEnv) {
     let restoreChanges = async () => {
         if(watcher.process) watcher.process.close();
         if(changedFiles.size > 0) {
-            console.log("\nRestoring changed files...".yellow);
-            let stash = true;
-            await git().env('LC_ALL', 'C').stash(["--include-untracked"]).then( value => value.indexOf("Saved") == 0 || (stash = false))
-            let lastSha = await getLastDeployedSha(cmdEnv.server)
-            await git().checkout(lastSha)
-            
-            await cmdEnv.applyLastEnvironmentDeployedToServerChanges()
-            for(let changedFile of changedFiles) {
-                await removeFileFromCurrentTest(cmdEnv.server, changedFile);
-            }
-            await cmdEnv.unApplyLastEnvironmentDeployedToServerChanges()
-
-            await execa('ssh', [cmdEnv.server,"find " + SERVER_IN_PROGRESS_TEST_FILE + " -size 0 -delete "]) //Remove file if empty
-
-            await git().checkout("-")
-            if (stash) await git().stash(["pop"])
+            await restoreServerFilesToLastDeployed(cmdEnv, changedFiles);
         }
         fs.unlinkSync("."+IN_PROGRESS_TEST_FILE)
     }
@@ -114,6 +99,41 @@ async function otherFilesContiousReload(cmdEnv) {
 }
 exports.otherFilesContiousReload = otherFilesContiousReload
 
+/* ************************************ */
+async function restoreServerFilesToLastDeployed(cmdEnv, changedFiles) {
+    console.log("\nRestoring changed files...".yellow);
+
+    // Clean up any env-swap markers left by applyCurrentCommandEnvironmentChanges before
+    // stashing. These files are gitignored, so git stash --include-untracked ignores them.
+    // If they survive into _undoSpecific(lastEnv) they create ghost env files that are
+    // untracked at lastSha, causing "git checkout -" to abort.
+    await cmdEnv.unApplyCurrentCommandEnvironmentChanges();
+
+    let stashed = false;
+    await git().env('LC_ALL', 'C').stash(["--include-untracked"])
+        .then(value => { stashed = value.indexOf("Saved") === 0; })
+        .catch(() => {});
+
+    const lastSha = await getLastDeployedSha(cmdEnv.server);
+    if (!lastSha) throw new Error("Cannot restore server files: no previous deploy found on server.");
+    await git().checkout(lastSha);
+
+    await cmdEnv.applyLastEnvironmentDeployedToServerChanges();
+
+    for (const changedFile of changedFiles) {
+        await removeFileFromCurrentTest(cmdEnv.server, changedFile);
+    }
+
+    await cmdEnv.unApplyLastEnvironmentDeployedToServerChanges();
+
+    await execa('ssh', [cmdEnv.server, "find " + SERVER_IN_PROGRESS_TEST_FILE + " -size 0 -delete"])
+        .catch(() => {});
+
+    await git().checkout("-");
+    if (stashed) await git().stash(["pop"]);
+}
+exports.restoreServerFilesToLastDeployed = restoreServerFilesToLastDeployed
+
 /* ************************************ */
 async function addFileToCurrentTest(server, changedFile, changedFiles, changeType, restoreChanges) {
     let inUse = "";
@@ -146,6 +166,7 @@ async function removeFileFromCurrentTest(server, changedFile) {
     await execa('ssh', [server, "sed -i '/" + changedFile.split("/").join("\\/") + "/d'  " + SERVER_IN_PROGRESS_TEST_FILE]).catch( () => {/* ignore files removed by user */} );
     console.log(" reset ".brightGreen + changedFile);
 }
+exports.removeFileFromCurrentTest = removeFileFromCurrentTest
 
 /* ************************************ */
 function checkNoTestsRunningOnServer(server) {

package/lib/task_lists/test_syncFile.js

@@ -24,6 +24,7 @@ async function syncFile(server, localFile) {
             "--prune-empty-dirs",
             "--chmod=Fg+w",
             "--no-perms",
+            "--no-group",
             "--no-t",
             "--filter='merge " + path.resolve(__dirname,"rsyncFilter-pre.txt") + "'",
             "--filter='merge " + path.resolve(__dirname,"rsyncFilter-post.txt") + "'"],

package/lib/task_lists/updateFromServer_definitions.js

@@ -0,0 +1,135 @@
+require('colors');
+const Listr = require('listr');
+const UpdaterRenderer = require('listr-update-renderer');
+const VerboseRenderer = require('listr-verbose-renderer');
+const { getFilteredDefinitions } = require('./common_definitions.js')
+const axios = require("axios");
+const fs = require("fs/promises");
+
+async function getRefs(servername, def) {
+    const uri = `https://${servername}.cultofbits.com/recordm/recordm/definitions/${def.id}`
+    const response = await axios.get(uri);
+
+    if(response.status != 200){
+        throw new Error(`HTTP Error Response: ${response.status} ${response.statusText}`);
+    }
+
+    const fields = response.data.fieldDefinitions;
+    return [...new Set(get$Refs(fields))];
+}
+function get$Refs(fields){
+    let refs = [];
+    for(f of fields){
+        if(f.configuration.keys.Reference){
+            refs.push(f.configuration.keys.Reference.args.definition);
+        }
+        if(f.fields) {
+            const childRefs = get$Refs(f.fields);
+            if(childRefs.length > 0) refs.push(...childRefs)
+        }
+    }
+    return refs
+}
+
+async function exportDefinitionChanges(servername, def, dataPath) {
+
+    const uri = `https://${servername}.cultofbits.com/recordm/recordm/definitions/${def.id}/changes`
+    const response = await axios.get(uri);
+
+    if(response.status == 204){
+        // this is probably an error
+        throw new Error(`Definition "${def.name}" [${def.id}] has no tagged Changes.`);
+
+    } else if(response.status != 200){
+        throw new Error(`HTTP Error Response: ${response.status} ${response.statusText}`);
+    }
+
+    // write every change on a single line
+    const stringified = "[\n" + response.data.map(change => "  " + JSON.stringify(change)).join(',\n') + "\n]\n";
+
+    await fs.writeFile(dataPath, stringified, 'utf-8');
+}
+
+async function exportDefinitionIdx(defs, dataPath) {
+   await fs.writeFile(dataPath, defs.map(d => d.name).join('\n'), 'utf-8')
+}
+
+async function getViewsForDef(servername, definition, dataPath) {
+    const definitionId = definition.id
+    const uri = `https://${servername}.cultofbits.com/recordm/user/settings/${definition.views}/definitions-${definitionId}/views?`
+
+    const response = await axios.get(uri);
+
+    if(response.status != 200){
+        throw new Error(`HTTP Error Response: ${response.status} ${response.statusText}`);
+    }
+
+    let userViews = response.data.filter(v => v.isShared)
+
+    if(response.data.length == 0)
+        return
+
+    userViews = response.data.map(v => {
+        v.value = JSON.stringify( JSON.parse(v.value).filter(f => f.visible == true) )
+        return v
+    })
+
+    const jsonLines = userViews.map(v => JSON.stringify({
+        key: v.key,
+        value: v.value,
+        user: v.user,
+    })) .join('\n');
+
+    await fs.writeFile(dataPath, jsonLines)
+}
+
+function getDefinitionsFromServer(servername, defs, definitionsPath, viewsPath, customization, args) {
+
+    return new Listr(
+        [
+            {
+                title: `(${customization}) Definitions: `.bold + "searching for definitions matching queries",
+                task: async ctx =>  ctx.defs = await getFilteredDefinitions(servername, defs)
+            },
+            {
+                title: `(${customization}) Definitions: `.bold + "enriching metadata",
+                task: async ctx => {
+                    const definitions = await Promise.all(ctx.defs
+                        .map(async d => ({id: d.id, name: d.name, views: d.views, refs: await getRefs(servername, d)}))
+                    )
+
+                    // we'll sort by refs, Defs that reference others must come after them
+                    definitions.sort((a, b) => {
+                        if (a.refs.includes(b.name)){
+                            return 1;
+                        }
+
+                        if(b.refs.includes(a.name)){
+                            return -1;
+                        }
+
+                        return a.refs.length - b.refs.length;
+                    })
+
+                    ctx.defs = definitions
+                }
+            },
+            {
+                title: `(${customization}) Definitions: `.bold + "exporting changes",
+                task: async ctx => {
+                    for( d of ctx.defs ){ await exportDefinitionChanges(servername, d, definitionsPath + `${d.name}.json`)}
+                    await exportDefinitionIdx(ctx.defs, definitionsPath + "_index")
+                }
+            },
+            {
+                title: `(${customization}) Definitions: `.bold + "exporting views",
+                task: async ctx => { for (d of ctx.defs.filter(d => d.views )){ await getViewsForDef(servername, d, viewsPath + `${d.name}.jsonl`)} }
+            },
+        ],{
+            renderer: args.verbose ? VerboseRenderer : UpdaterRenderer,
+            collapse: false
+        })
+}
+
+
+exports.getDefinitionsFromServer = getDefinitionsFromServer

package/lib/task_lists/updateFromServer_domains.js

@@ -0,0 +1,50 @@
+require('colors');
+const Listr = require('listr');
+const UpdaterRenderer = require('listr-update-renderer');
+const VerboseRenderer = require('listr-verbose-renderer');
+const axios = require("axios");
+const fs = require("fs/promises");
+
+async function domainsFromServer(servername, domainsFilter, exportPath, customization, args) {
+    await new Listr(
+        [
+            { title: `(${customization}) Domains: `.bold + "searching for domains matching the queries" ,
+                task: async ctx => ctx.domains = await getDomains(servername, domainsFilter, exportPath) },
+            { title: `(${customization}) Domains: `.bold + "exporting domains " ,
+                task: ctx => ctx.domains.forEach( d => exportDomain(d, exportPath))  }
+        ],{
+            renderer: args.verbose ? VerboseRenderer : UpdaterRenderer,
+            collapse: false
+        })
+        .run()
+}
+
+function match(query, domain) {
+    // simple matching for now
+    return (domain.name && domain.name.includes(query)) ||
+        (domain.description && domain.description.includes(query) )
+}
+
+async function getDomains(servername, filters, exportPath) {
+
+    const uri = `https://${servername}.cultofbits.com/recordm/recordm/domains`
+    const response = await axios.get( uri );
+
+    if(response.status != 200){
+        throw new Error(`HTTP Error Response: ${response.status} ${response.statusText}`);
+    }
+
+    const matchesAny = (domain) => filters.filter(q => match(q, domain)).length > 0;
+
+    return response.data.filter( matchesAny )
+}
+
+async function exportDomain(domain, rootPath) {
+    const d = {
+        name: domain.name,
+        definitions: domain.definitions.map(d => d.name).sort()
+    }
+    await fs.writeFile(rootPath + domain.name + ".json", JSON.stringify(d, null, 2) )
+}
+
+exports.getDomainsFromServer = domainsFromServer