@dynamicweb/cli 1.1.1 → 2.0.0-beta.0

package/bin/commands/command.js

@@ -1,10 +1,10 @@
 import fetch from 'node-fetch';
 import path from 'path';
 import fs from 'fs';
-import { setupEnv, getAgent } from './env.js';
+import { setupEnv, getAgent, createCommandError } from './env.js';
 import { setupUser } from './login.js';
 
-const exclude = ['_', '$0', 'command', 'list', 'json', 'verbose', 'v', 'host', 'protocol', 'apiKey', 'env', 'output']
+const exclude = ['_', '$0', 'command', 'list', 'json', 'verbose', 'v', 'host', 'protocol', 'apiKey', 'env', 'output', 'auth', 'clientId', 'clientSecret', 'clientIdEnv', 'clientSecretEnv', 'oauth']
 
 export function commandCommand() {
     return {
@@ -33,18 +33,18 @@ export function commandCommand() {
             try {
                 output.verboseLog(`Running command ${argv.command}`);
                 await handleCommand(argv, output);
-                output.finish();
             } catch (err) {
                 output.fail(err);
+                process.exitCode = 1;
+            } finally {
                 output.finish();
-                process.exit(1);
             }
         }
     }
 }
 
 async function handleCommand(argv, output) {
-    let env = await setupEnv(argv);
+    let env = await setupEnv(argv, output);
     let user = await setupUser(argv, env);
     if (argv.list) {
         const properties = await getProperties(env, user, argv.command);
@@ -58,18 +58,7 @@ async function handleCommand(argv, output) {
 }
 
 async function getProperties(env, user, command) {
-    return `This option currently doesn't work`
-    let res = await fetch(`${env.protocol}://${env.host}/Admin/Api/CommandByName?name=${command}`, {
-        method: 'GET',
-        headers: {
-            'Authorization': `Bearer ${user.apiKey}`
-        },
-        agent: getAgent(env.protocol)
-    })
-    if (res.ok) {
-        let body = await res.json()
-        return body.model.propertyNames
-    }
+    throw createCommandError('The --list option is not currently implemented for commands.');
 }
 
 function getQueryParams(argv) {
@@ -148,12 +137,6 @@ function createCommandOutput(argv) {
     };
 }
 
-function createCommandError(message, status, details = null) {
-    const error = new Error(message);
-    error.status = status;
-    error.details = details;
-    return error;
-}
 
 async function parseJsonSafe(res) {
     try {

package/bin/commands/env.js

@@ -41,12 +41,27 @@ export function envCommand() {
                     type: 'boolean',
                     description: 'List all users in environment, uses positional [env] if used, otherwise current env'
                 })
+                .option('output', {
+                    choices: ['json'],
+                    describe: 'Outputs a single JSON response for automation-friendly parsing'
+                })
         },
-        handler: (argv) => handleEnv(argv)
+        handler: async (argv) => {
+            const output = createEnvOutput(argv);
+
+            try {
+                await handleEnv(argv, output);
+            } catch (err) {
+                output.fail(err);
+                process.exitCode = 1;
+            } finally {
+                output.finish();
+            }
+        }
     }
 }
 
-export async function setupEnv(argv) {
+export async function setupEnv(argv, output = null) {
     let env = {};
     let askEnv = true;
 
@@ -62,13 +77,17 @@ export async function setupEnv(argv) {
 
     if (askEnv && getConfig().env) {
         env = getConfig().env[argv.env] || getConfig().env[getConfig()?.current?.env];
-        if (!env.protocol) {
-            console.log('Protocol for environment not set, defaulting to https');
+        if (env && !env.protocol) {
+            logMessage(argv, 'Protocol for environment not set, defaulting to https');
             env.protocol = 'https';
         }
     }
     else if (askEnv) {
-        console.log('Current environment not set, please set it')
+        if (isJsonOutput(argv)) {
+            throw createCommandError('Current environment not set, please set it');
+        }
+
+        logMessage(argv, 'Current environment not set, please set it');
         await interactiveEnv(argv, {
             environment: {
                 type: 'input'
@@ -76,20 +95,35 @@ export async function setupEnv(argv) {
             interactive: {
                 default: true
             }
-        })
+        }, output)
         env = getConfig().env[getConfig()?.current?.env];
     }
+
+    if (!env || Object.keys(env).length === 0) {
+        throw createCommandError('Unable to resolve the current environment.');
+    }
+
     return env;
 }
 
-async function handleEnv(argv) {
+async function handleEnv(argv, output) {
     if (argv.users) {
-        let env = argv.env || getConfig().current.env;
-        console.log(`Users in environment ${env}: ${Object.keys(getConfig().env[env].users || {})}`);
+        const cfg = getConfig();
+        let env = argv.env || cfg.current?.env;
+        const envConfig = cfg.env?.[env];
+        if (!envConfig) {
+            throw createCommandError(`Environment '${env}' does not exist`, 404);
+        }
+        const users = Object.keys(envConfig.users || {});
+        output.addData({ environment: env, users });
+        output.log(`Users in environment ${env}: ${users}`);
     } else if (argv.env) {
-        changeEnv(argv)
+        const result = await changeEnv(argv, output);
+        output.addData(result);
     } else if (argv.list) {
-        console.log(`Existing environments: ${Object.keys(getConfig().env || {})}`)
+        const environments = Object.keys(getConfig().env || {});
+        output.addData({ environments });
+        output.log(`Existing environments: ${environments}`);
     } else {
         await interactiveEnv(argv, {
             environment: {
@@ -102,12 +136,12 @@ async function handleEnv(argv) {
             interactive: {
                 default: true
             }
-        })
+        }, output)
     }
 }
 
-export async function interactiveEnv(argv, options) {
-    if (argv.verbose) console.info('Setting up new environment')
+export async function interactiveEnv(argv, options, output) {
+    verboseLog(argv, 'Setting up new environment');
     const result = {};
     for (const [key, config] of Object.entries(options)) {
         if (key === 'interactive') continue;
@@ -122,8 +156,7 @@ export async function interactiveEnv(argv, options) {
     }
     getConfig().env = getConfig().env || {};
     if (!result.environment || !result.environment.trim()) {
-        console.log('Environment name cannot be empty');
-        return;
+        throw createCommandError('Environment name cannot be empty');
     }
     getConfig().env[result.environment] = getConfig().env[result.environment] || {};
     if (result.host) {
@@ -135,8 +168,7 @@ export async function interactiveEnv(argv, options) {
             getConfig().env[result.environment].protocol = hostSplit[0];
             getConfig().env[result.environment].host = hostSplit[1];
         } else {
-            console.log(`Issues resolving host ${result.host}`);
-            return;
+            throw createCommandError(`Issues resolving host ${result.host}`);
         }
     }
     if (result.environment) {
@@ -144,14 +176,34 @@ export async function interactiveEnv(argv, options) {
         getConfig().current.env = result.environment;
     }
     updateConfig();
-    console.log(`Your current environment is now ${getConfig().current.env}`);
-    console.log(`To change the host of your environment, use the command 'dw env'`)
+    logMessage(argv, `Your current environment is now ${getConfig().current.env}`);
+    logMessage(argv, `To change the host of your environment, use the command 'dw env'`);
+
+    const currentEnv = getConfig().env[result.environment];
+    const data = {
+        environment: result.environment,
+        protocol: currentEnv.protocol,
+        host: currentEnv.host || null,
+        current: getConfig().current.env
+    };
+
+    if (output) {
+        output.addData(data);
+    }
+
+    return data;
 }
 
-async function changeEnv(argv) {
-    if (!Object.keys(getConfig().env).includes(argv.env)) {
-        console.log(`The specified environment ${argv.env} doesn't exist, please create it`);
-        await interactiveEnv(argv, {
+async function changeEnv(argv, output) {
+    const environments = getConfig().env || {};
+
+    if (!Object.keys(environments).includes(argv.env)) {
+        if (isJsonOutput(argv)) {
+            throw createCommandError(`The specified environment ${argv.env} doesn't exist, please create it`, 404);
+        }
+
+        logMessage(argv, `The specified environment ${argv.env} doesn't exist, please create it`);
+        return await interactiveEnv(argv, {
             environment: {
                 type: 'input',
                 default: argv.env,
@@ -165,10 +217,75 @@ async function changeEnv(argv) {
             interactive: {
                 default: true
             }
-        })
+        }, output)
     } else {
         getConfig().current.env = argv.env;
         updateConfig();
-        console.log(`Your current environment is now ${getConfig().current.env}`);
+        const data = {
+            environment: argv.env,
+            current: getConfig().current.env
+        };
+        logMessage(argv, `Your current environment is now ${getConfig().current.env}`);
+        return data;
+    }
+}
+
+export function isJsonOutput(argv) {
+    return argv?.output === 'json';
+}
+
+export function createCommandError(message, status = 1, details = null) {
+    const error = new Error(message);
+    error.status = status;
+    error.details = details;
+    return error;
+}
+
+function logMessage(argv, ...args) {
+    if (!isJsonOutput(argv)) {
+        console.log(...args);
     }
 }
+
+function verboseLog(argv, ...args) {
+    if (argv?.verbose && !isJsonOutput(argv)) {
+        console.info(...args);
+    }
+}
+
+function createEnvOutput(argv) {
+    const response = {
+        ok: true,
+        command: 'env',
+        operation: argv.users ? 'users' : argv.list ? 'list' : argv.env ? 'select' : 'setup',
+        status: 200,
+        data: [],
+        errors: [],
+        meta: {}
+    };
+
+    return {
+        json: isJsonOutput(argv),
+        addData(entry) {
+            response.data.push(entry);
+        },
+        log(...args) {
+            if (!this.json) {
+                console.log(...args);
+            }
+        },
+        fail(err) {
+            response.ok = false;
+            response.status = err?.status || 1;
+            response.errors.push({
+                message: err?.message || 'Unknown env command error.',
+                details: err?.details ?? null
+            });
+        },
+        finish() {
+            if (this.json) {
+                console.log(JSON.stringify(response, null, 2));
+            }
+        }
+    };
+}