@dynamicweb/cli 1.1.1 → 2.0.0-beta.0

package/bin/commands/login.js

@@ -1,8 +1,12 @@
 import fetch from 'node-fetch';
-import { interactiveEnv, getAgent } from './env.js'
+import { interactiveEnv, getAgent, isJsonOutput, createCommandError } from './env.js'
 import { updateConfig, getConfig } from './config.js';
 import { input, password } from '@inquirer/prompts';
 
+const DEFAULT_OAUTH_TOKEN_PATH = '/Admin/OAuth/token';
+const DEFAULT_CLIENT_ID_ENV = 'DW_CLIENT_ID';
+const DEFAULT_CLIENT_SECRET_ENV = 'DW_CLIENT_SECRET';
+
 export function loginCommand() {
     return {
         command: 'login [user]',
@@ -12,8 +16,27 @@ export function loginCommand() {
             .positional('user', {
                 describe: 'user'
             })
+            .option('oauth', {
+                type: 'boolean',
+                describe: 'Configures OAuth client_credentials authentication for the current environment'
+            })
+            .option('output', {
+                choices: ['json'],
+                describe: 'Outputs a single JSON response for automation-friendly parsing'
+            })
         },
-        handler: (argv) => handleLogin(argv)
+        handler: async (argv) => {
+            const output = createLoginOutput(argv);
+
+            try {
+                await handleLogin(argv, output);
+            } catch (err) {
+                output.fail(err);
+                process.exitCode = 1;
+            } finally {
+                output.finish();
+            }
+        }
     }
 }
 
@@ -26,17 +49,24 @@ export async function setupUser(argv, env) {
         askLogin = false;
     }
 
+    if (!user.apiKey && shouldUseOAuth(argv, env)) {
+        return await authenticateWithOAuth(argv, env);
+    }
+
     if (!user.apiKey && env.users && (argv.user || env.current?.user)) {
         user = env.users[argv.user] || env.users[env.current?.user];
         askLogin = false;
     }
 
     if (askLogin && argv.host) {
-        console.log('Please add an --apiKey to the command as overriding the host requires that.')
-        process.exit();
+        throw createCommandError('Please add an --apiKey, or provide OAuth client credentials when overriding the host.');
     }
     else if (askLogin) {
-        console.log('Current user not set, please login')
+        if (isJsonOutput(argv)) {
+            throw createCommandError('Current user not set, please login');
+        }
+
+        logMessage(argv, 'Current user not set, please login');
         await interactiveLogin(argv, {
             environment: {
                 type: 'input',
@@ -59,27 +89,40 @@ export async function setupUser(argv, env) {
     return user;
 }
 
-async function handleLogin(argv) {
-    argv.user ? changeUser(argv) : await interactiveLogin(argv, {
+async function handleLogin(argv, output) {
+    if (shouldUseOAuth(argv, getCurrentEnv(argv))) {
+        if (isJsonOutput(argv)) {
+            output.addData(await nonInteractiveOAuthLogin(argv));
+        } else {
+            output.addData(await interactiveOAuthLogin(argv, output));
+        }
+    } else if (argv.user) {
+        output.addData(await changeUser(argv));
+    } else {
+        if (isJsonOutput(argv)) {
+            throw createCommandError('Interactive login is not supported with --output json. Use --apiKey, or configure OAuth with --oauth --clientIdEnv/--clientSecretEnv.');
+        }
+        output.addData(await interactiveLogin(argv, {
         environment: {
             type: 'input',
             default: getConfig()?.current?.env || 'dev',
             prompt: 'if-no-arg'
           },
-          username: { 
+          username: {
             type: 'input'
           },
-          password: { 
+          password: {
             type: 'password'
           },
           interactive: {
               default: true
           }
-    })
+    }, output))
+    }
 }
 
-export async function interactiveLogin(argv, options) {
-    if (argv.verbose) console.info('Now logging in')
+export async function interactiveLogin(argv, options, output) {
+    verboseLog(argv, 'Now logging in');
     const result = {};
     for (const [key, config] of Object.entries(options)) {
         if (key === 'interactive') continue;
@@ -95,41 +138,57 @@ export async function interactiveLogin(argv, options) {
         });
     }
     if (!getConfig().env || !getConfig().env[result.environment] || !getConfig().env[result.environment].host || !getConfig().env[result.environment].protocol) {
-        if (!argv.host)
-            console.log(`The environment specified is missing parameters, please specify them`)
-        await interactiveEnv(argv, {
-            environment: {
-                type: 'input',
-                default: result.environment,
-                prompt: 'never'
-            },
-            host: {
-                describe: 'Enter your host including protocol, i.e "https://yourHost.com":',
-                type: 'input',
-                prompt: 'always'
-            },
-            interactive: {
-                default: true
-            }
-        })
+        if (argv.host) {
+            ensureEnvironmentFromArgs(result.environment, argv);
+        } else {
+            logMessage(argv, `The environment specified is missing parameters, please specify them`);
+            await interactiveEnv(argv, {
+                environment: {
+                    type: 'input',
+                    default: result.environment,
+                    prompt: 'never'
+                },
+                host: {
+                    describe: 'Enter your host including protocol, i.e "https://yourHost.com":',
+                    type: 'input',
+                    prompt: 'always'
+                },
+                interactive: {
+                    default: true
+                }
+            }, output)
+        }
     }
-    await loginInteractive(result, argv.verbose);
+    return await loginInteractive(result, argv.verbose, argv);
 }
 
-async function loginInteractive(result, verbose) {
+async function loginInteractive(result, verbose, argv) {
     var protocol = getConfig().env[result.environment].protocol;
     var token = await login(result.username, result.password, result.environment, protocol, verbose);
-    if (!token) return;
+    if (!token) {
+        throw createCommandError(`Could not fetch a login token for user ${result.username}.`);
+    }
     var apiKey = await getApiKey(token, result.environment, protocol, verbose)
-    if (!apiKey) return;
+    if (!apiKey) {
+        throw createCommandError(`Could not create an API Key for the logged in user ${result.username}.`);
+    }
     getConfig().env = getConfig().env || {};
     getConfig().env[result.environment].users = getConfig().env[result.environment].users || {};
     getConfig().env[result.environment].users[result.username] = getConfig().env[result.environment].users[result.username] || {};
     getConfig().env[result.environment].users[result.username].apiKey = apiKey;
     getConfig().env[result.environment].current = getConfig().env[result.environment].current || {};
     getConfig().env[result.environment].current.user = result.username;
-    console.log("You're now logged in as " + result.username)
+    getConfig().env[result.environment].current.authType = 'user';
+    logMessage(argv, "You're now logged in as " + result.username);
     updateConfig();
+
+    return {
+        environment: result.environment,
+        username: result.username,
+        apiKey,
+        host: getConfig().env[result.environment].host,
+        protocol
+    };
 }
 
 async function login(username, password, env, protocol, verbose) {
@@ -153,14 +212,13 @@ async function login(username, password, env, protocol, verbose) {
     }
     else {
         if (verbose) console.info(res)
-        console.log(`Login attempt failed with username ${username}, please verify its a valid user in your Dynamicweb solution.`)
+        throw createCommandError(`Login attempt failed with username ${username}, please verify its a valid user in your Dynamicweb solution.`, res.status)
     }
 }
 
 function parseCookies (cookieHeader) {
     const list = {};
     if (!cookieHeader) {
-        console.log(`Could not get the necessary information from the login request, please verify its a valid user in your Dynamicweb solution.`)
         return list;
     }
 
@@ -173,10 +231,6 @@ function parseCookies (cookieHeader) {
         list[name] = decodeURIComponent(value);
     });
 
-    if (!list.user) {
-        console.log(`Could not get the necessary information from the login request, please verify its a valid user in your Dynamicweb solution.`)
-    }
-
     return list;
 }
 
@@ -193,7 +247,7 @@ async function getToken(user, env, protocol, verbose) {
     }
     else {
         if (verbose) console.info(res)
-        console.log(`Could not fetch the token for the logged in user ${user}, please verify its a valid user in your Dynamicweb solution.`)
+        throw createCommandError(`Could not fetch the token for the logged in user ${user}, please verify its a valid user in your Dynamicweb solution.`, res.status)
     }
 }
 
@@ -218,12 +272,297 @@ async function getApiKey(token, env, protocol, verbose) {
     }
     else {
         if (verbose) console.info(res)
-        console.log(`Could not create an API Key for the logged in user, please verify its a valid user in your Dynamicweb solution.`)
+        throw createCommandError(`Could not create an API Key for the logged in user, please verify its a valid user in your Dynamicweb solution.`, res.status)
     }
 }
 
 async function changeUser(argv) {
+    if (!getConfig().current?.env || !getConfig().env?.[getConfig().current.env]) {
+        throw createCommandError('Current environment not set, please set it before changing user.');
+    }
+
+    getConfig().env[getConfig().current.env].current = getConfig().env[getConfig().current.env].current || {};
     getConfig().env[getConfig().current.env].current.user = argv.user;
+    getConfig().env[getConfig().current.env].current.authType = 'user';
     updateConfig();
-    console.log(`You're now logged in as ${getConfig().env[getConfig().current.env].current.user}`);
-}
+    logMessage(argv, `You're now logged in as ${getConfig().env[getConfig().current.env].current.user}`);
+
+    return {
+        environment: getConfig().current.env,
+        username: getConfig().env[getConfig().current.env].current.user
+    };
+}
+
+async function interactiveOAuthLogin(argv, output) {
+    verboseLog(argv, 'Configuring OAuth client credentials authentication');
+
+    const currentEnvName = getConfig()?.current?.env || 'dev';
+    const environment = await input({
+        message: 'environment',
+        default: currentEnvName
+    });
+    const existingEnv = getConfig()?.env?.[environment] || {};
+    const existingAuth = existingEnv.auth || {};
+
+    const result = {
+        environment,
+        clientIdEnv: argv.clientIdEnv || existingAuth.clientIdEnv || DEFAULT_CLIENT_ID_ENV,
+        clientSecretEnv: argv.clientSecretEnv || existingAuth.clientSecretEnv || DEFAULT_CLIENT_SECRET_ENV
+    };
+
+    if (!argv.clientIdEnv) {
+        result.clientIdEnv = await input({
+            message: 'clientIdEnv',
+            default: result.clientIdEnv
+        });
+    }
+
+    if (!argv.clientSecretEnv) {
+        result.clientSecretEnv = await input({
+            message: 'clientSecretEnv',
+            default: result.clientSecretEnv
+        });
+    }
+
+    if (argv.host) {
+        ensureEnvironmentFromArgs(result.environment, argv);
+    } else if (!getConfig().env || !getConfig().env[result.environment] || !getConfig().env[result.environment].host || !getConfig().env[result.environment].protocol) {
+        logMessage(argv, 'The environment specified is missing parameters, please specify them');
+        await interactiveEnv(argv, {
+            environment: {
+                type: 'input',
+                default: result.environment,
+                prompt: 'never'
+            },
+            host: {
+                describe: 'Enter your host including protocol, i.e "https://yourHost.com":',
+                type: 'input',
+                prompt: 'always'
+            },
+            interactive: {
+                default: true
+            }
+        }, output);
+    }
+
+    const oauthResult = await finalizeOAuthLogin(result.environment, result.clientIdEnv, result.clientSecretEnv, argv);
+
+    logMessage(argv, `OAuth authentication is now configured for ${result.environment}`);
+
+    return oauthResult;
+}
+
+async function nonInteractiveOAuthLogin(argv) {
+    verboseLog(argv, 'Configuring OAuth client credentials authentication (non-interactive)');
+
+    const environment = getConfig()?.current?.env;
+    if (!environment) {
+        throw createCommandError('No environment set. Configure one with "dw env" first.');
+    }
+
+    if (argv.host) {
+        ensureEnvironmentFromArgs(environment, argv);
+    } else if (!getConfig().env?.[environment]?.host) {
+        throw createCommandError(`Environment "${environment}" has no host configured. Pass --host or set it up with "dw env" first.`);
+    }
+
+    const clientIdEnv = argv.clientIdEnv || getConfig().env?.[environment]?.auth?.clientIdEnv || DEFAULT_CLIENT_ID_ENV;
+    const clientSecretEnv = argv.clientSecretEnv || getConfig().env?.[environment]?.auth?.clientSecretEnv || DEFAULT_CLIENT_SECRET_ENV;
+
+    return await finalizeOAuthLogin(environment, clientIdEnv, clientSecretEnv, argv);
+}
+
+async function finalizeOAuthLogin(environment, clientIdEnv, clientSecretEnv, argv) {
+    const env = getConfig().env[environment];
+    const oauthConfig = resolveOAuthConfig({
+        ...argv,
+        clientIdEnv,
+        clientSecretEnv,
+        oauth: true
+    }, env);
+
+    const tokenResult = await fetchOAuthToken(env, oauthConfig, argv.verbose);
+
+    getConfig().current = getConfig().current || {};
+    getConfig().current.env = environment;
+    env.auth = {
+        type: 'oauth_client_credentials',
+        clientIdEnv,
+        clientSecretEnv
+    };
+    env.current = env.current || {};
+    env.current.authType = 'oauth_client_credentials';
+    delete env.current.user;
+    updateConfig();
+
+    return {
+        environment,
+        authType: 'oauth_client_credentials',
+        clientIdEnv,
+        clientSecretEnv,
+        expires: tokenResult.expires || null
+    };
+}
+
+async function authenticateWithOAuth(argv, env) {
+    const oauthConfig = resolveOAuthConfig(argv, env, true);
+    const tokenResult = await fetchOAuthToken(env, oauthConfig, argv.verbose);
+
+    return {
+        apiKey: tokenResult.token,
+        authType: 'oauth_client_credentials',
+        expires: tokenResult.expires || null
+    };
+}
+
+function shouldUseOAuth(argv, env = {}) {
+    if (argv.auth === 'user') {
+        return false;
+    }
+
+    if (argv.oauth || argv.auth === 'oauth') {
+        return true;
+    }
+
+    if (argv.clientId || argv.clientSecret || argv.clientIdEnv || argv.clientSecretEnv) {
+        return true;
+    }
+
+    if (env?.current?.authType) {
+        return env.current.authType === 'oauth_client_credentials';
+    }
+
+    return env?.auth?.type === 'oauth_client_credentials';
+}
+
+function resolveOAuthConfig(argv, env = {}, requireCredentials = true) {
+    const authConfig = env?.auth || {};
+    const clientIdEnv = argv.clientIdEnv || authConfig.clientIdEnv || DEFAULT_CLIENT_ID_ENV;
+    const clientSecretEnv = argv.clientSecretEnv || authConfig.clientSecretEnv || DEFAULT_CLIENT_SECRET_ENV;
+    const clientId = argv.clientId || process.env[clientIdEnv];
+    const clientSecret = argv.clientSecret || process.env[clientSecretEnv];
+
+    if (requireCredentials) {
+        if (!clientId) {
+            throw createCommandError(`OAuth client ID not found. Set --clientId or export ${clientIdEnv}.`);
+        }
+
+        if (!clientSecret) {
+            throw createCommandError(`OAuth client secret not found. Set --clientSecret or export ${clientSecretEnv}.`);
+        }
+    }
+
+    return {
+        clientId,
+        clientSecret,
+        clientIdEnv,
+        clientSecretEnv
+    };
+}
+
+async function fetchOAuthToken(env, oauthConfig, verbose) {
+    const res = await fetch(`${env.protocol}://${env.host}${DEFAULT_OAUTH_TOKEN_PATH}`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({
+            grant_type: 'client_credentials',
+            client_id: oauthConfig.clientId,
+            client_secret: oauthConfig.clientSecret
+        }),
+        agent: getAgent(env.protocol)
+    });
+
+    const body = await parseJsonSafe(res);
+
+    if (!res.ok) {
+        if (verbose) {
+            console.info(res);
+        }
+
+        throw createCommandError(`OAuth token request failed at ${DEFAULT_OAUTH_TOKEN_PATH}.`, res.status, body);
+    }
+
+    const token = body?.token || body?.Token;
+    const expires = body?.expires || body?.Expires || null;
+
+    if (!token) {
+        throw createCommandError('OAuth token response did not include a token.', res.status, body);
+    }
+
+    return { token, expires };
+}
+
+function getCurrentEnv(argv) {
+    if (argv.host) {
+        return {
+            host: argv.host,
+            protocol: argv.protocol || 'https'
+        };
+    }
+
+    return getConfig()?.env?.[getConfig()?.current?.env] || {};
+}
+
+function ensureEnvironmentFromArgs(environment, argv) {
+    getConfig().env = getConfig().env || {};
+    getConfig().env[environment] = getConfig().env[environment] || {};
+    getConfig().env[environment].host = argv.host;
+    getConfig().env[environment].protocol = argv.protocol || 'https';
+    getConfig().current = getConfig().current || {};
+    getConfig().current.env = environment;
+    updateConfig();
+}
+
+function logMessage(argv, ...args) {
+    if (!isJsonOutput(argv)) {
+        console.log(...args);
+    }
+}
+
+function verboseLog(argv, ...args) {
+    if (argv?.verbose && !isJsonOutput(argv)) {
+        console.info(...args);
+    }
+}
+
+function createLoginOutput(argv) {
+    const response = {
+        ok: true,
+        command: 'login',
+        operation: shouldUseOAuth(argv, getCurrentEnv(argv)) ? 'oauth-login' : argv.user ? 'select-user' : 'login',
+        status: 200,
+        data: [],
+        errors: [],
+        meta: {}
+    };
+
+    return {
+        json: isJsonOutput(argv),
+        addData(entry) {
+            response.data.push(entry);
+        },
+        fail(err) {
+            response.ok = false;
+            response.status = err?.status || 1;
+            response.errors.push({
+                message: err?.message || 'Unknown login command error.',
+                details: err?.details ?? null
+            });
+        },
+        finish() {
+            if (this.json) {
+                console.log(JSON.stringify(response, null, 2));
+            }
+        }
+    };
+}
+
+async function parseJsonSafe(res) {
+    try {
+        return await res.json();
+    } catch {
+        return null;
+    }
+}

package/bin/commands/query.js

@@ -1,9 +1,9 @@
 import fetch from 'node-fetch';
-import { setupEnv, getAgent } from './env.js';
+import { setupEnv, getAgent, createCommandError } from './env.js';
 import { setupUser } from './login.js';
 import { input } from '@inquirer/prompts';
 
-const exclude = ['_', '$0', 'query', 'list', 'i', 'l', 'interactive', 'verbose', 'v', 'host', 'protocol', 'apiKey', 'env', 'output']
+const exclude = ['_', '$0', 'query', 'list', 'i', 'l', 'interactive', 'verbose', 'v', 'host', 'protocol', 'apiKey', 'env', 'output', 'auth', 'clientId', 'clientSecret', 'clientIdEnv', 'clientSecretEnv', 'oauth']
 
 export function queryCommand() {
     return {
@@ -24,7 +24,8 @@ export function queryCommand() {
                 })
                 .option('output', {
                     choices: ['json'],
-                    describe: 'Outputs a single JSON response for automation-friendly parsing'
+                    describe: 'Outputs a single JSON response for automation-friendly parsing',
+                    conflicts: 'interactive'
                 })
         },
         handler: async (argv) => {
@@ -33,32 +34,35 @@ export function queryCommand() {
             try {
                 output.verboseLog(`Running query ${argv.query}`);
                 await handleQuery(argv, output);
-                output.finish();
             } catch (err) {
                 output.fail(err);
+                if (!output.json) {
+                    console.error(err.stack || err.message || String(err));
+                }
+                process.exitCode = 1;
+            } finally {
                 output.finish();
-                process.exit(1);
             }
         }
     }
 }
 
 async function handleQuery(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.query);
         output.addData(properties);
         output.log(properties);
     } else {
-        let response = await runQuery(env, user, argv.query, await getQueryParams(argv));
+        let response = await runQuery(env, user, argv.query, await getQueryParams(env, user, argv, output));
         output.addData(response);
         output.log(response);
     }
 }
 
 async function getProperties(env, user, query) {
-    let res = await fetch(`${env.protocol}://${env.host}/Admin/Api/QueryByName?name=${query}`, {
+    let res = await fetch(`${env.protocol}://${env.host}/Admin/Api/QueryByName?name=${encodeURIComponent(query)}`, {
         method: 'GET',
         headers: {
             'Authorization': `Bearer ${user.apiKey}`
@@ -67,7 +71,7 @@ async function getProperties(env, user, query) {
     })
     if (res.ok) {
         let body = await res.json()
-        if (body.model.properties.groups === undefined) {
+        if (body?.model?.properties?.groups === undefined) {
             throw createCommandError('Unable to fetch query parameters.', res.status, body);
         }
         return body.model.properties.groups.filter(g => g.name === 'Properties')[0].fields.map(field => `${field.name} (${field.typeName})`)
@@ -76,14 +80,12 @@ async function getProperties(env, user, query) {
     throw createCommandError('Unable to fetch query parameters.', res.status, await parseJsonSafe(res));
 }
 
-async function getQueryParams(argv) {
+async function getQueryParams(env, user, argv, output) {
     let params = {}
     if (argv.interactive) {
-        let env = await setupEnv(argv);
-        let user = await setupUser(argv, env);
         let properties = await getProperties(env, user, argv.query);
-        console.log('The following properties will be requested:')
-        console.log(properties)
+        output.log('The following properties will be requested:')
+        output.log(properties)
         for (const p of properties) {
             const value = await input({ message: p });
             if (value) {
@@ -156,12 +158,6 @@ function createQueryOutput(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 {