@dynamicweb/cli 1.0.16 → 1.1.1

package/bin/commands/query.js

@@ -1,102 +1,172 @@
-import fetch from 'node-fetch';
-import { setupEnv, getAgent } from './env.js';
-import { setupUser } from './login.js';
-import yargsInteractive from 'yargs-interactive';
-
-const exclude = ['_', '$0', 'query', 'list', 'i', 'l', 'interactive']
-
-export function queryCommand() {
-    return {
-        command: 'query [query]', 
-        describe: 'Runs the given query', 
-        builder: (yargs) => {
-            return yargs
-            .positional('query', {
-                describe: 'The query to execute'
-            })
-            .option('list', {
-                alias: 'l',
-                describe: 'Lists all the properties for the query'
-            })
-            .option('interactive', {
-                alias: 'i',
-                describe: 'Runs in interactive mode to ask for query parameters one by one'
-            })
-        },
-        handler: (argv) => {
-            if (argv.verbose) console.info(`Running query ${argv.query}`)
-            handleQuery(argv)
-        }
-    }
-}
-
-async function handleQuery(argv) {
-    let env = await setupEnv(argv);
-    let user = await setupUser(argv, env);
-    if (argv.list) {
-        console.log(await getProperties(argv))
-    } else {
-        let response = await runQuery(env, user, argv.query, await getQueryParams(argv))
-        console.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}`, {
-        method: 'GET',
-        headers: {
-            'Authorization': `Bearer ${user.apiKey}`
-        },
-        agent: getAgent(env.protocol)
-    })
-    if (res.ok) {
-        let body = await res.json()
-        if (body.model.properties.groups === undefined) {
-            console.log('Unable to fetch query parameters');
-            process.exit(1);
-        }
-        return body.model.properties.groups.filter(g => g.name === 'Properties')[0].fields.map(field => `${field.name} (${field.typeName})`)
-    }
-    console.log('Unable to fetch query parameters');
-    console.log(res);
-    process.exit(1);
-}
-
-async function getQueryParams(argv) {
-    let params = {}
-    if (argv.interactive) {
-        let props = { interactive: { default: true }}
-        let properties = await getProperties(argv);
-        console.log('The following properties will be requested:')
-        console.log(properties)
-        Array.from(properties).forEach(p => props[p] = { type: 'input', prompt: 'if-no-arg'})
-        await yargsInteractive()
-        .interactive(props)
-        .then((result) => {
-            Object.keys(result).filter(k => !exclude.includes(k)).forEach(k => {
-                if (result[k]) params[k] = result[k]
-            })
-        });
-    } else {
-        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), {
-        method: 'GET',
-        headers: {
-            'Authorization': `Bearer ${user.apiKey}`
-        },
-        agent: getAgent(env.protocol)
-    })
-    if (!res.ok) {
-        console.log(`Error when doing request ${res.url}`)
-        process.exit(1);
-    }
-    return await res.json()
-}
+import fetch from 'node-fetch';
+import { setupEnv, getAgent } 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']
+
+export function queryCommand() {
+    return {
+        command: 'query [query]',
+        describe: 'Runs the given query',
+        builder: (yargs) => {
+            return yargs
+                .positional('query', {
+                    describe: 'The query to execute'
+                })
+                .option('list', {
+                    alias: 'l',
+                    describe: 'Lists all the properties for the query'
+                })
+                .option('interactive', {
+                    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'
+                })
+        },
+        handler: async (argv) => {
+            const output = createQueryOutput(argv);
+
+            try {
+                output.verboseLog(`Running query ${argv.query}`);
+                await handleQuery(argv, output);
+                output.finish();
+            } catch (err) {
+                output.fail(err);
+                output.finish();
+                process.exit(1);
+            }
+        }
+    }
+}
+
+async function handleQuery(argv, output) {
+    let env = await setupEnv(argv);
+    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));
+        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}`, {
+        method: 'GET',
+        headers: {
+            'Authorization': `Bearer ${user.apiKey}`
+        },
+        agent: getAgent(env.protocol)
+    })
+    if (res.ok) {
+        let body = await res.json()
+        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})`)
+    }
+
+    throw createCommandError('Unable to fetch query parameters.', res.status, await parseJsonSafe(res));
+}
+
+async function getQueryParams(argv) {
+    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)
+        for (const p of properties) {
+            const value = await input({ message: p });
+            if (value) {
+                const fieldName = p.split(' (')[0];
+                params[fieldName] = value;
+            }
+        }
+    } else {
+        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), {
+        method: 'GET',
+        headers: {
+            'Authorization': `Bearer ${user.apiKey}`
+        },
+        agent: getAgent(env.protocol)
+    })
+    if (!res.ok) {
+        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));
+            }
+        }
+    };
+}
+
+function createCommandError(message, status, details = null) {
+    const error = new Error(message);
+    error.status = status;
+    error.details = details;
+    return error;
+}
+
+async function parseJsonSafe(res) {
+    try {
+        return await res.json();
+    } catch {
+        return null;
+    }
+}

package/bin/commands/swift.js

@@ -1,79 +1,79 @@
-import { exec } from 'child_process';
-import { Agent } from 'https';
-import path from 'path';
-import fetch from 'node-fetch';
-
-const agent = new Agent({
-    rejectUnauthorized: false
-})
-
-export function swiftCommand() {
-    return {
-        command: 'swift [outPath]', 
-        describe: 'Downloads latest swift version to outPath', 
-        builder: (yargs) => {
-            return yargs
-            .positional('outPath', {
-                default: '.',
-                describe: 'Location for the swift solution'
-            })
-            .option('tag', {
-                alias: 't',
-                describe: 'The version tag or branch to clone'
-            })
-            .option('list', {
-                alias: 'l',
-                describe: 'Lists all release versions'
-            })
-            .option('nightly', {
-                alias: 'n',
-                describe: 'Will pull #HEAD, as default is latest release'
-            })
-            .option('force', {})
-        },
-        handler: (argv) => {
-            if (argv.verbose) console.info(`Downloading latest swift to :${argv.outPath}`)
-            handleSwift(argv)
-        }
-    }
-}
-
-async function handleSwift(argv) {
-    if (argv.list) {
-        console.log(await getVersions(false))
-    } else {
-        let degitCommand
-        if (argv.nightly) {
-            degitCommand = `npx degit dynamicweb/swift ${argv.force ? '--force' : ''} "${path.resolve(argv.outPath)}"`
-        } else {
-            degitCommand = `npx degit dynamicweb/swift#${argv.tag ? argv.tag : await getVersions(true)} ${argv.force ? '--force' : ''} "${path.resolve(argv.outPath)}"`
-        }
-        if (argv.verbose) console.info(`Executing command: ${degitCommand}`)
-        exec(degitCommand, (error, stdout, stderr) => {
-            if (error) {
-                console.log(`error: ${error.message}`);
-                return;
-            }
-            if (stderr) {
-                console.log(stderr);
-                return;
-            }
-            console.log(stdout);
-        });
-    }
-}
-
-async function getVersions(latest) {
-    let res = await fetch(`https://api.github.com/repos/dynamicweb/swift/releases${latest ? '/latest' : ''}`, {
-        method: 'GET',
-        agent: agent
-    });
-    if (res.ok) {
-        let body = await res.json()
-        if (latest) {
-            return body.tag_name
-        } else {
-            return body.map(a => a.tag_name)
-        }
-    }
+import { execFile } from 'child_process';
+import { Agent } from 'https';
+import path from 'path';
+import fetch from 'node-fetch';
+
+const agent = new Agent({
+    rejectUnauthorized: false
+})
+
+export function swiftCommand() {
+    return {
+        command: 'swift [outPath]', 
+        describe: 'Downloads latest swift version to outPath', 
+        builder: (yargs) => {
+            return yargs
+            .positional('outPath', {
+                default: '.',
+                describe: 'Location for the swift solution'
+            })
+            .option('tag', {
+                alias: 't',
+                describe: 'The version tag or branch to clone'
+            })
+            .option('list', {
+                alias: 'l',
+                describe: 'Lists all release versions'
+            })
+            .option('nightly', {
+                alias: 'n',
+                describe: 'Will pull #HEAD, as default is latest release'
+            })
+            .option('force', {})
+        },
+        handler: async (argv) => {
+            if (argv.verbose) console.info(`Downloading latest swift to :${argv.outPath}`)
+            await handleSwift(argv)
+        }
+    }
+}
+
+async function handleSwift(argv) {
+    if (argv.list) {
+        console.log(await getVersions(false))
+    } else {
+        const repo = argv.nightly
+            ? 'dynamicweb/swift'
+            : `dynamicweb/swift#${argv.tag ? argv.tag : await getVersions(true)}`;
+        const args = ['degit', repo];
+        if (argv.force) args.push('--force');
+        args.push(path.resolve(argv.outPath));
+        if (argv.verbose) console.info(`Executing: npx ${args.join(' ')}`)
+        execFile('npx', args, (error, stdout, stderr) => {
+            if (error) {
+                console.log(`error: ${error.message}`);
+                return;
+            }
+            if (stderr) {
+                console.log(stderr);
+                return;
+            }
+            console.log(stdout);
+        });
+    }
+}
+
+async function getVersions(latest) {
+    let res = await fetch(`https://api.github.com/repos/dynamicweb/swift/releases${latest ? '/latest' : ''}`, {
+        method: 'GET',
+        agent: agent
+    });
+    if (res.ok) {
+        let body = await res.json()
+        if (latest) {
+            return body.tag_name
+        } else {
+            return body.map(a => a.tag_name)
+        }
+    }
 }

package/bin/downloader.js

@@ -1,67 +1,70 @@
-import { Response } from 'node-fetch';
-import fs from 'fs';
-
-/**
- * Extracts the file name from the HTTP response.
- * @param {Response} res - The HTTP response object.
- * @returns {string} The extracted file name.
- */
-export function getFileNameFromResponse(res, dirPath) {
-    const header = res.headers.get('content-disposition');
-    const parts = header?.split(';');
-    
-    if (!parts) {
-        const msg = `No files found in directory '${dirPath}', if you want to download all folders recursively include the -r flag`;
-        throw new Error(msg);
-    }
-
-    return parts[1].split('=')[1].replace('+', ' ');
-}
-
-/**
- * Attempts to extract the file name from an HTTP response.
- * If extraction fails, logs the error message to the console.
- *
- * @param {Object} res - The HTTP response object to extract the file name from.
- * @param {string} dirPath - The directory path to use for file name resolution.
- * @returns {string|null} The extracted file name, or null if extraction fails.
- */
-export function tryGetFileNameFromResponse(res, dirPath) {
-    try {
-        return getFileNameFromResponse(res, dirPath);
-    } catch (err) {
-        console.error(err.message);
-        return null;
-    }
-}
-
-/**
- * Downloads a file with progress reporting.
- * @param {Response} res - The response from which to read the stream data.
- * @param {string} filePath - The path to write the file to.
- * @param {Object} options - Options for the download.
- * @param {(receivedBytes: number, elapsedMillis: number, isFirstChunk: boolean) => void} options.onData - Callback invoked with each data chunk.
- * @returns {Promise<void>} Resolves when the download is complete.
- */
-export function downloadWithProgress(res, filePath, options) {
-    const fileStream = fs.createWriteStream(filePath);
-    return new Promise((resolve, reject) => {
-        let receivedBytes = 0;
-        let startTime = Date.now();
-
-        res.body.pipe(fileStream);
-        res.body.on("error", reject);
-        fileStream.on("finish", resolve);
-
-        res.body.on("data", chunk => {
-            const isFirstChunk = receivedBytes === 0;
-            const elapsed = Date.now() - startTime;
-            
-            receivedBytes += chunk.length;
-
-            if (options?.onData) {
-                options.onData(receivedBytes, elapsed, isFirstChunk);
-            }
-        });
-    });
-}
+import { Response } from 'node-fetch';
+import fs from 'fs';
+
+/**
+ * Extracts the file name from the HTTP response.
+ * @param {Response} res - The HTTP response object.
+ * @returns {string} The extracted file name.
+ */
+export function getFileNameFromResponse(res, dirPath) {
+    const header = res.headers.get('content-disposition');
+    const parts = header?.split(';');
+
+    if (!parts) {
+        const msg = `No files found in directory '${dirPath}', if you want to download all folders recursively include the -r flag`;
+        throw new Error(msg);
+    }
+
+    return parts[1].split('=')[1].replaceAll('+', ' ');
+}
+
+/**
+ * Attempts to extract the file name from an HTTP response.
+ * If extraction fails, logs the error message to the console.
+ *
+ * @param {Object} res - The HTTP response object to extract the file name from.
+ * @param {string} dirPath - The directory path to use for file name resolution.
+ * @param {boolean} verbose - Whether to log missing download information.
+ * @returns {string|null} The extracted file name, or null if extraction fails.
+ */
+export function tryGetFileNameFromResponse(res, dirPath, verbose = false) {
+    try {
+        return getFileNameFromResponse(res, dirPath);
+    } catch (err) {
+        if (verbose) {
+            console.log(err.message);
+        }
+        return null;
+    }
+}
+
+/**
+ * Downloads a file with progress reporting.
+ * @param {Response} res - The response from which to read the stream data.
+ * @param {string} filePath - The path to write the file to.
+ * @param {Object} options - Options for the download.
+ * @param {(receivedBytes: number, elapsedMillis: number, isFirstChunk: boolean) => void} options.onData - Callback invoked with each data chunk.
+ * @returns {Promise<void>} Resolves when the download is complete.
+ */
+export function downloadWithProgress(res, filePath, options) {
+    const fileStream = fs.createWriteStream(filePath);
+    return new Promise((resolve, reject) => {
+        let receivedBytes = 0;
+        let startTime = Date.now();
+
+        res.body.pipe(fileStream);
+        res.body.on("error", reject);
+        fileStream.on("finish", resolve);
+
+        res.body.on("data", chunk => {
+            const isFirstChunk = receivedBytes === 0;
+            const elapsed = Date.now() - startTime;
+
+            receivedBytes += chunk.length;
+
+            if (options?.onData) {
+                options.onData(receivedBytes, elapsed, isFirstChunk);
+            }
+        });
+    });
+}

package/bin/extractor.js

@@ -1,28 +1,28 @@
-import extract from 'extract-zip';
-
-/**
- * Extracts files from a zip archive with progress reporting.
- *
- * @param {string} filePath - The path to the zip file to extract.
- * @param {string} destinationPath - The directory where files will be extracted.
- * @param {Object} [options] - Optional settings.
- * @param {(processedEntries: number, totalEntries: number, percent: string) => void} [options.onEntry] - Callback invoked on each entry extracted.
- *   Receives the number of processed files, total entry count, and percent complete as arguments.
- * @returns {Promise<void>} A promise that resolves when extraction is complete.
- */
-export function extractWithProgress(filePath, destinationPath, options) {
-    let processedEntries = 0;
-
-    return extract(filePath, {
-        dir: destinationPath,
-        onEntry: (_, zipFile) => {
-            processedEntries++;
-
-            const percent = Math.floor((processedEntries / zipFile.entryCount) * 100).toFixed(0);
-
-            if (options?.onEntry) {
-                options.onEntry(processedEntries, zipFile.entryCount, percent);
-            }
-        }
-    }, function (err) {});
-}
+import extract from 'extract-zip';
+
+/**
+ * Extracts files from a zip archive with progress reporting.
+ *
+ * @param {string} filePath - The path to the zip file to extract.
+ * @param {string} destinationPath - The directory where files will be extracted.
+ * @param {Object} [options] - Optional settings.
+ * @param {(processedEntries: number, totalEntries: number, percent: string) => void} [options.onEntry] - Callback invoked on each entry extracted.
+ *   Receives the number of processed files, total entry count, and percent complete as arguments.
+ * @returns {Promise<void>} A promise that resolves when extraction is complete.
+ */
+export function extractWithProgress(filePath, destinationPath, options) {
+    let processedEntries = 0;
+
+    return extract(filePath, {
+        dir: destinationPath,
+        onEntry: (_, zipFile) => {
+            processedEntries++;
+
+            const percent = Math.floor((processedEntries / zipFile.entryCount) * 100).toFixed(0);
+
+            if (options?.onEntry) {
+                options.onEntry(processedEntries, zipFile.entryCount, percent);
+            }
+        }
+    }, function (err) {});
+}