@dynamicweb/cli 1.1.2 → 2.0.0-beta.2

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']
+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 {
@@ -22,30 +22,47 @@ export function queryCommand() {
                     alias: 'i',
                     describe: 'Runs in interactive mode to ask for query parameters one by one'
                 })
+                .option('output', {
+                    choices: ['json'],
+                    describe: 'Outputs a single JSON response for automation-friendly parsing',
+                    conflicts: 'interactive'
+                })
         },
-        handler: (argv) => {
-            if (argv.verbose) console.info(`Running query ${argv.query}`)
-            handleQuery(argv)
+        handler: async (argv) => {
+            const output = createQueryOutput(argv);
+
+            try {
+                output.verboseLog(`Running query ${argv.query}`);
+                await handleQuery(argv, output);
+            } catch (err) {
+                output.fail(err);
+                if (!output.json) {
+                    console.error(err.stack || err.message || String(err));
+                }
+                process.exitCode = 1;
+            } finally {
+                output.finish();
+            }
         }
     }
 }
 
-async function handleQuery(argv) {
-    let env = await setupEnv(argv);
+async function handleQuery(argv, output) {
+    let env = await setupEnv(argv, output);
     let user = await setupUser(argv, env);
     if (argv.list) {
-        console.log(await getProperties(argv))
+        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))
-        console.log(response)
+        let response = await runQuery(env, user, argv.query, await getQueryParams(env, user, argv, output));
+        output.addData(response);
+        output.log(response);
     }
 }
 
-async function getProperties(argv) {
-    let env = await setupEnv(argv);
-    let user = await setupUser(argv, env);
-
-    let res = await fetch(`${env.protocol}://${env.host}/Admin/Api/QueryByName?name=${argv.query}`, {
+async function getProperties(env, user, query) {
+    let res = await fetch(`${env.protocol}://${env.host}/Admin/Api/QueryByName?name=${encodeURIComponent(query)}`, {
         method: 'GET',
         headers: {
             'Authorization': `Bearer ${user.apiKey}`
@@ -54,38 +71,60 @@ async function getProperties(argv) {
     })
     if (res.ok) {
         let body = await res.json()
-        if (body.model.properties.groups === undefined) {
-            console.log('Unable to fetch query parameters');
-            process.exit(1);
+        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})`)
+        return extractQueryPropertyPrompts(body);
     }
-    console.log('Unable to fetch query parameters');
-    console.log(res);
-    process.exit(1);
+
+    throw createCommandError('Unable to fetch query parameters.', res.status, await parseJsonSafe(res));
 }
 
-async function getQueryParams(argv) {
+export async function getQueryParams(env, user, argv, output, deps = {}) {
     let params = {}
+    const getPropertiesFn = deps.getPropertiesFn || getProperties;
+    const promptFn = deps.promptFn || input;
     if (argv.interactive) {
-        let properties = await getProperties(argv);
-        console.log('The following properties will be requested:')
-        console.log(properties)
-        for (const p of properties) {
-            const value = await input({ message: p });
-            if (value) {
-                const fieldName = p.split(' (')[0];
-                params[fieldName] = value;
-            }
-        }
+        let properties = await getPropertiesFn(env, user, argv.query);
+        output.log('The following properties will be requested:')
+        output.log(properties)
+        params = await buildInteractiveQueryParams(properties, promptFn);
     } else {
-        Object.keys(argv).filter(k => !exclude.includes(k)).forEach(k => params[k] = argv[k])
+        params = buildQueryParamsFromArgv(argv);
+    }
+    return params
+}
+
+export function extractQueryPropertyPrompts(body) {
+    const fields = body?.model?.properties?.groups?.find(g => g.name === 'Properties')?.fields || [];
+    return fields.map(field => `${field.name} (${field.typeName})`);
+}
+
+export function getFieldNameFromPropertyPrompt(prompt) {
+    return prompt.replace(/\s+\([^)]+\)$/, '');
+}
+
+export async function buildInteractiveQueryParams(properties, promptFn = input) {
+    const params = {};
+
+    for (const propertyPrompt of properties) {
+        const value = await promptFn({ message: propertyPrompt });
+        if (value) {
+            params[getFieldNameFromPropertyPrompt(propertyPrompt)] = value;
+        }
     }
+
+    return params;
+}
+
+export function buildQueryParamsFromArgv(argv) {
+    let params = {}
+    Object.keys(argv).filter(k => !exclude.includes(k)).forEach(k => params[k] = argv[k])
     return params
 }
 
 async function runQuery(env, user, query, params) {
-    let res = await fetch(`${env.protocol}://${env.host}/Admin/Api/${query}?` + new URLSearchParams(params), {
+    let res = await fetch(`${env.protocol}://${env.host}/Admin/Api/${encodeURIComponent(query)}?` + new URLSearchParams(params), {
         method: 'GET',
         headers: {
             'Authorization': `Bearer ${user.apiKey}`
@@ -93,8 +132,61 @@ async function runQuery(env, user, query, params) {
         agent: getAgent(env.protocol)
     })
     if (!res.ok) {
-        console.log(`Error when doing request ${res.url}`)
-        process.exit(1);
+        throw createCommandError(`Error when doing request ${res.url}`, res.status, await parseJsonSafe(res));
     }
     return await res.json()
-}
+}
+
+function createQueryOutput(argv) {
+    const response = {
+        ok: true,
+        command: 'query',
+        operation: argv.list ? 'list' : 'run',
+        status: 200,
+        data: [],
+        errors: [],
+        meta: {
+            query: argv.query
+        }
+    };
+
+    return {
+        json: argv.output === 'json',
+        response,
+        log(value) {
+            if (!this.json) {
+                console.log(value);
+            }
+        },
+        verboseLog(...args) {
+            if (argv.verbose && !this.json) {
+                console.info(...args);
+            }
+        },
+        addData(entry) {
+            response.data.push(entry);
+        },
+        fail(err) {
+            response.ok = false;
+            response.status = err?.status || 1;
+            response.errors.push({
+                message: err?.message || 'Unknown query 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/index.js

@@ -33,14 +33,30 @@ yargs(hideBin(process.argv))
         description: 'Run with verbose logging'
     })
     .option('protocol', {
-        description: 'Allows setting the protocol used, only used together with --host, defaulting to https'
+        description: 'Set the protocol used with --host (defaults to https)'
     })
     .option('host', {
-        description: 'Allows setting the host used, only allowed if an --apiKey is specified'
+        description: 'Allows setting the host used, only allowed if an --apiKey or OAuth client credentials are specified'
     })
     .option('apiKey', {
         description: 'Allows setting the apiKey for an environmentless execution of the CLI command'
     })
+    .option('auth', {
+        choices: ['user', 'oauth'],
+        description: 'Overrides the authentication mode for the command'
+    })
+    .option('clientId', {
+        description: 'OAuth client ID used together with --auth oauth'
+    })
+    .option('clientSecret', {
+        description: 'OAuth client secret used together with --auth oauth. WARNING: passing this on the command line can expose the secret via shell history and process listings. Prefer using --clientSecretEnv to reference a secret stored in an environment variable instead.'
+    })
+    .option('clientIdEnv', {
+        description: 'Environment variable name that contains the OAuth client ID'
+    })
+    .option('clientSecretEnv', {
+        description: 'Environment variable name that contains the OAuth client secret'
+    })
     .demandCommand()
     .parse()
 
@@ -49,14 +65,31 @@ function baseCommand() {
         command: '$0',
         describe: 'Shows the current env and user being used',
         handler: () => {
-            if (Object.keys(getConfig()).length === 0) {
+            const cfg = getConfig();
+            if (Object.keys(cfg).length === 0) {
                 console.log('To login to a solution use `dw login`')
                 return;
-            } 
-            console.log(`Environment: ${getConfig()?.current?.env}`)
-            console.log(`User: ${getConfig()?.env[getConfig()?.current?.env]?.current?.user}`)
-            console.log(`Protocol: ${getConfig()?.env[getConfig()?.current?.env]?.protocol}`)
-            console.log(`Host: ${getConfig()?.env[getConfig()?.current?.env]?.host}`)
+            }
+            const currentEnv = cfg?.env?.[cfg?.current?.env];
+            if (!currentEnv) {
+                console.log(`Environment '${cfg?.current?.env}' is not configured.`);
+                console.log('To login to a solution use `dw login`');
+                return;
+            }
+            const authType = currentEnv?.current?.authType;
+
+            console.log(`Environment: ${cfg?.current?.env}`);
+            if (authType === 'oauth_client_credentials') {
+                console.log('Authentication: OAuth client credentials');
+            } else if (currentEnv?.current?.user) {
+                console.log(`User: ${currentEnv.current.user}`);
+            }
+            if (currentEnv.protocol) {
+                console.log(`Protocol: ${currentEnv.protocol}`);
+            }
+            if (currentEnv.host) {
+                console.log(`Host: ${currentEnv.host}`);
+            }
         }
     }
 }

package/package.json

@@ -2,7 +2,7 @@
   "name": "@dynamicweb/cli",
   "type": "module",
   "description": "CLI for interacting with Dynamicweb 10 solutions from the command line.",
-  "version": "1.1.2",
+  "version": "2.0.0-beta.2",
   "main": "bin/index.js",
   "files": [
     "bin/**"
@@ -15,7 +15,8 @@
     "devops"
   ],
   "scripts": {
-    "test": "node --test"
+    "test": "node --test",
+    "qa:smoke": "node qa/run-smoke.mjs"
   },
   "author": "Dynamicweb A/S (https://www.dynamicweb.com)",
   "repository": {

package/bin/commands/files.test.js

@@ -1,76 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-
-import { resolveFilePath, resolveUploadOutput } from './files.js';
-
-test('resolveUploadOutput falls back to a console-compatible output object', () => {
-    const output = resolveUploadOutput();
-
-    assert.equal(typeof output.log, 'function');
-    assert.equal(typeof output.addData, 'function');
-    assert.equal(typeof output.mergeMeta, 'function');
-    assert.deepEqual(output.response.meta, {});
-
-    output.mergeMeta({ chunks: 1, filesProcessed: 2 });
-
-    assert.deepEqual(output.response.meta, {
-        chunks: 1,
-        filesProcessed: 2
-    });
-});
-
-test('resolveUploadOutput preserves custom logging and merges meta when mergeMeta is absent', () => {
-    const calls = [];
-    const data = [];
-    const output = {
-        log: (...args) => calls.push(args),
-        addData: (entry) => data.push(entry),
-        response: {
-            meta: {
-                existing: true
-            }
-        }
-    };
-
-    const resolved = resolveUploadOutput(output);
-
-    resolved.log('Uploading chunk 1 of 1');
-    resolved.addData({ file: 'addon.nupkg' });
-    resolved.mergeMeta({ chunks: 1 });
-
-    assert.deepEqual(calls, [[ 'Uploading chunk 1 of 1' ]]);
-    assert.deepEqual(data, [{ file: 'addon.nupkg' }]);
-    assert.deepEqual(resolved.response.meta, {
-        existing: true,
-        chunks: 1
-    });
-});
-
-test('resolveUploadOutput initializes response.meta for partial output objects', () => {
-    const resolved = resolveUploadOutput({
-        log: () => {},
-        response: {}
-    });
-
-    resolved.mergeMeta({ chunks: 2 });
-
-    assert.deepEqual(resolved.response.meta, {
-        chunks: 2
-    });
-});
-
-test('resolveFilePath throws when no matching file exists', () => {
-    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'dw-cli-files-test-'));
-
-    try {
-        assert.throws(
-            () => resolveFilePath(path.join(tempDir, 'missing*.nupkg')),
-            /Could not find any files with the name/
-        );
-    } finally {
-        fs.rmSync(tempDir, { recursive: true, force: true });
-    }
-});

package/bin/commands/install.test.js

@@ -1,48 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-
-import { createInstallOutput } from './install.js';
-
-test('createInstallOutput suppresses regular logs in json mode and emits the final envelope', () => {
-    const logCalls = [];
-    const infoCalls = [];
-    const originalLog = console.log;
-    const originalInfo = console.info;
-
-    console.log = (...args) => logCalls.push(args);
-    console.info = (...args) => infoCalls.push(args);
-
-    try {
-        const output = createInstallOutput({
-            output: 'json',
-            queue: true,
-            verbose: true
-        });
-
-        output.log('hidden');
-        output.verboseLog('hidden verbose');
-        output.addData({ type: 'install', filename: 'addon.nupkg' });
-        output.mergeMeta({ resolvedPath: '/tmp/addon.nupkg' });
-        output.finish();
-
-        assert.deepEqual(infoCalls, []);
-        assert.equal(logCalls.length, 1);
-
-        const rendered = JSON.parse(logCalls[0][0]);
-        assert.deepEqual(rendered, {
-            ok: true,
-            command: 'install',
-            operation: 'install',
-            status: 200,
-            data: [{ type: 'install', filename: 'addon.nupkg' }],
-            errors: [],
-            meta: {
-                queued: true,
-                resolvedPath: '/tmp/addon.nupkg'
-            }
-        });
-    } finally {
-        console.log = originalLog;
-        console.info = originalInfo;
-    }
-});