@dynamicweb/cli 1.0.0

package/README.md

@@ -0,0 +1,171 @@
+# DynamicWeb CLI
+
+## What is it?
+DynamicWeb CLI is a powerful command line tool designed to help developers quickly and efficiently manage any given DynamicWeb 10 solution they may have access to. These tools inclues an easy setup and handling of different environments, access to the Management API and an easy way to update a Swift solution.
+
+Logging into a DynamicWeb 10 solution through the DynamicWeb CLI will create an API Key for the given user, which in turn lets you use any Queries and Commands the solution had, meaning you can control everything you can do in the backend, from your command line.
+With this, you can hook it up to your own build pipelines and processes, if certain requests needs to happen before or after deployments or changes.
+
+The DynamicWeb CLI can also help with active development of custom addins to solutions. With a simple `dw install` command it will upload and install your custom code to a solution.
+
+Extracting files from solutions is just as easy as well, with the DynamicWeb CLI you can list out the structure of a solution and get full exports of the files structure and the database. Importing files into a solution is just as easy as well, as long as you have access to the files and the solution, they can be imported with a simple command using the DynamicWeb CLI.
+
+## Get started
+To install after cloning, move to project dir and run
+> $ npm install -g .
+> 
+> $ npm install
+
+Note that specific installations might be necessary if you're faced with errors such as 'Error [ERR_MODULE_NOT_FOUND]: Cannot find package 'yargs''
+In which case try installing that module specifically;
+> $ npm install yargs
+
+## Commands
+All commands and options can be viewed by running
+> $ dw --help
+> 
+> $ dw \<command\> --help
+
+### Users and environments
+As most commands are pulling or pushing data from the DW admin API, the necessary authorization is required.
+
+To generate an Api-key that the CLI will use, login to your environment
+> $ dw login
+
+This will start an interactive session asking for username and password, as well as the name of the environment, so it's possible to switch between different environments easily.
+It will also ask for a host, if you're running a local environment, set this to the host it starts up with, i.e `localhost:6001`.
+
+Each environment has its own users, and each user has its own Api-key assigned to it, swap between environments by using
+> $ dw env \<env\>
+
+and swap between users by simply supplying the name of the user in the login command
+> $ dw login \<username\>
+
+You can view the current environment and user being used by simply typing
+> $ dw
+
+The configuration will automatically be created when setting up your first environment, but if you already have an Api-key you want to use for a user, you can modify the config directly in the file located in `usr/.dwc`. The structure should look like the following
+```json
+{
+    "env": {
+        "dev": {
+            "host": "localhost:6001",
+            "users": {
+                "DemoUser": {
+                    "apiKey": "<keyPrefix>.<key>"
+                }
+            },
+            "current": {
+                "user": "DemoUser"
+            }
+        }
+    },
+    "current": {
+        "env": "dev"
+    }
+}
+```
+
+### Files
+> $ dw files \<dirPath\> \<outPath\>
+
+The files command is used to list out and export the structure in your Dynamicweb files archive, as such is has multiple options;
+- `-l` `--list`         This will list the directory given in \<dirPath\>
+- `-f` `--includeFiles` The list will now also show all files in the directories
+- `-r` `--recursive`    By default it only handles the \<dirPath\>, but with this option it will handle all directories under this recursively
+- `-e` `--export`       It will export \<dirPath\> into \<outPath\> on your local machine, unzipped by default
+- `--raw`             This will keep the content zipped
+- `--iamstupid`       This will include the export of the /files/system/log and /files/.cache folders
+
+#### Examples
+Exporting all templates from current environment to local solution
+> $ cd DynamicWebSolution/Files
+> 
+> $ dw files templates ./templates -fre
+
+Listing the system files structure of the current environment
+> $ dw files system -lr
+
+### Swift
+> $ dw swift \<outPath\>
+
+The swift command is used to easily get your local environment up to date with the latest swift release. It will override all existing directories and content in those, which can then be adjusted in your source control afterwards. It has multiple options to specify which tag or branch to pull;
+- `-t` `--tag <tag>`  The tag/branch/release to pull
+- `-l` `--list`         Will list all the release versions
+- `-n` `--nightly`      Will pull #HEAD, as default is latest release
+- `--force`           Used if \<outPath\> is not an empty folder, to override all the content
+
+#### Examples
+Getting all the available releases
+> $ dw swift -l
+
+Pulling and overriding local solution with latest nightly build
+> $ cd DynamicWebSolution/Swift
+> 
+> $ dw swift . -n --force
+
+### Query
+> $ dw query \<query\>
+
+The query command will fire any query towards the admin Api with the given query parameters. This means any query parameter that's necessary for the given query, is required as an option in this command. It's also possible to list which parameters is necessary for the given query through the options;
+- `-l` `--list`         Will list all the properties for the given \<query\>
+- `-i` `--interactive`  Will perform the \<query\> but without any parameters, as they will be asked for one by one in interactive mode
+- `--<queryParam>`  Any parameter the query needs will be sent by '--key value'
+
+#### Examples
+Getting all properties for a query
+> $ dw query FileByName -l
+
+Getting file information on a specific file by name
+> $ dw query FileByName --name DefaultMail.html --directorypath /Templates/Forms/Mail
+
+### Command
+> $ dw command \<command\>
+
+Using command will, like query, fire any given command in the solution. It works like query, given the query parameters necessary, however if a `DataModel` is required for the command, it is given in a json-format, either through a path to a .json file or a literal json-string in the command.
+- `-l` `--list` Lists all the properties for the command, as well as the json model required **currently not working**
+- `--json` Takes a path to a .json file or a literal json, i.e --json '{ abc: "123" }'
+
+#### Examples
+Creating a copy of a page using a json-string
+> $ dw command PageCopy --json '{ "model": { "SourcePageId": 1189, "DestinationParentPageId": 1129 } }'
+
+Removing a page using a json file
+> $ dw command PageMove --json ./PageMove.json
+
+Where PageMove.json contains
+```json
+{ "model": { "SourcePageId": 1383, "DestinationParentPageId": 1376 } }
+```
+
+Deleting a page
+> $ dw command PageDelete --json '{ "id": "1383" }'
+
+### Install
+> $ dw install \<filePath\>
+
+Install is somewhat of a shorthand for a few commands. It will upload and install a given .dll or .nupkg addin to your current environment.
+
+It's meant to be used to easily apply custom dlls to a given project, it being local or otherwise, so after having a dotnet library built locally, this command can be run, pointing to the built .dll and it will handle the rest with all the addin installation, and it will be available in the DynamicWeb solution as soon as the command finishes.
+
+#### Examples
+> $ dw install ./bin/Release/net6.0/CustomProject.dll
+
+### Database
+> $ dw database \<outPath\>
+
+This command is used for various actions towards your current environments database.
+- `-e` `--export`       Exports your current environments database to a .bacpac file at \<outPath\>
+
+#### Examples
+> $ dw database -e ./backup
+
+### Config
+> $ dw config
+
+Config is used to manage the .dwc file through the CLI, given any prop it will create the key/value with the path to it.
+- `--<property>`  The path and name of the property to set
+
+#### Examples
+Changing the host for the dev environment
+> $ dw config --env.dev.host localhost:6001

package/bin/commands/command.js

@@ -0,0 +1,88 @@
+import fetch from 'node-fetch';
+import path from 'path';
+import fs from 'fs';
+import { setupEnv, getAgent } from './env.js';
+import { setupUser } from './login.js';
+
+const exclude = ['_', '$0', 'command', 'list', 'json']
+
+export function commandCommand() {
+    return {
+        command: 'command [command]', 
+        describe: 'Runs the given command', 
+        builder: (yargs) => {
+            return yargs
+            .positional('command', {
+                describe: 'The command to execute'
+            })
+            .option('json', {
+                describe: 'Literal json or location of json file to send'
+            })
+            .option('list', {
+                alias: 'l',
+                describe: 'Lists all the properties for the command, currently not working'
+            })
+        },
+        handler: (argv) => {
+            if (argv.verbose) console.info(`Running command ${argv.command}`)
+            handleCommand(argv)
+        }
+    }
+}
+
+async function handleCommand(argv) {
+    let env = await setupEnv(argv);
+    let user = await setupUser(argv, env);
+    if (argv.list) {
+        console.log(await getProperties(env, user, argv.command))
+    } else {
+        let response = await runCommand(env, user, argv.command, getQueryParams(argv), parseJsonOrPath(argv.json))
+        console.log(response)
+    }
+}
+
+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
+    }
+}
+
+function getQueryParams(argv) {
+    let params = {}
+    Object.keys(argv).filter(k => !exclude.includes(k)).forEach(k => params['Command.' + k] = argv[k])
+    return params
+}
+
+function parseJsonOrPath(json) {
+    if (!json) return
+    if (fs.existsSync(json)) {
+        return JSON.parse(fs.readFileSync(path.resolve(json)))
+    } else {
+        return JSON.parse(json)
+    }
+}
+
+async function runCommand(env, user, command, queryParams, data) {
+    let res = await fetch(`${env.protocol}://${env.host}/Admin/Api/${command}?` + new URLSearchParams(queryParams), {
+        method: 'POST',
+        body: JSON.stringify(data),
+        headers: {
+            'Authorization': `Bearer ${user.apiKey}`,
+            'Content-Type': 'application/json'
+        },
+        agent: getAgent(env.protocol)
+    })
+    if (!res.ok) {
+        console.log(`Error when doing request ${res.url}`)
+    }
+    return await res.json()
+}

package/bin/commands/config.js

@@ -0,0 +1,55 @@
+import os from 'os';
+import fs from 'fs';
+
+const configLocation = os.homedir() + '/.dwc';
+let localConfig;
+
+export function configCommand() {
+    return {
+        command: 'config',
+        describe: 'Edit the configs located in usr/.dwc',
+        handler: (argv) => handleConfig(argv),
+        builder: {
+            prop: {
+                type: 'string',
+                describe: 'Path to your config property, i.e --env.dev.host=newHost:1000'
+            }
+        }
+    }
+}
+
+export function setupConfig() {
+    try {
+        localConfig = JSON.parse(fs.readFileSync(configLocation));
+    } catch (e) {
+        localConfig = {}
+    }
+}
+
+export function getConfig() {
+    return localConfig;
+}
+
+export function handleConfig(argv) {
+    Object.keys(argv).forEach(a => {
+        if (a != '_' && a != '$0') {
+            resolveConfig(a, argv[a], config[a]);
+            updateConfig();
+        }
+    })
+}
+
+export function updateConfig() {
+    fs.writeFileSync(configLocation, JSON.stringify(localConfig));
+}
+
+function resolveConfig(key, obj, conf) {
+    if (typeof obj !== 'object' || !(obj instanceof Object)) {
+        return obj;
+    }
+    Object.keys(obj).forEach(a => {
+        conf[a] = conf[a] || {};
+        conf[a] = resolveConfig(key, obj[a], conf[a]);
+    })
+    return conf;
+}

package/bin/commands/database.js

@@ -0,0 +1,72 @@
+import fetch from 'node-fetch';
+import fs from 'fs';
+import _path from 'path';
+import { setupEnv, getAgent } from './env.js';
+import { setupUser } from './login.js';
+
+export function databaseCommand() {
+    return {
+        command: 'database [path]', 
+        describe: 'Handles database', 
+        builder: (yargs) => {
+            return yargs
+            .positional('path', {
+                describe: 'Path to the .bacpac file',
+                default: '.'
+            })
+            .option('export', {
+                alias: 'e',
+                type: 'boolean',
+                description: 'Exports the solutions database to a .bacpac file at [path]'
+            })
+        },
+        handler: (argv) => {
+            if (argv.verbose) console.info(`Handling database with path: ${argv.path}`)
+            handleDatabase(argv)
+        }
+    }
+}
+
+async function handleDatabase(argv) {
+    let env = await setupEnv(argv);
+    let user = await setupUser(argv, env);
+
+    if (argv.export) {
+        await download(env, user, argv.path, argv.verbose);
+    }
+}
+
+async function download(env, user, path, verbose) {
+    let filename = 'database.bacpac';
+    fetch(`${env.protocol}://${env.host}/Admin/Api/DatabaseDownload`, {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${user.apiKey}`,
+            'content-type': 'application/json'
+        },
+        agent: getAgent(env.protocol)
+    }).then(async (res) => {
+        if (verbose) console.log(res)
+        const header = res.headers.get('Content-Disposition');
+        const parts = header?.split(';');
+        if (!parts || !header.includes('attachment')) {
+            console.log('Failed download, check users database permissions')
+            if (verbose) console.log(await res.json())
+            return;
+        }
+        filename = parts[1].split('=')[1];
+        return res;
+    }).then(async (res) => {
+        if (!res) {
+            return;
+        }
+        const fileStream = fs.createWriteStream(_path.resolve(`${_path.resolve(path)}/${filename}`));
+        await new Promise((resolve, reject) => {
+            res.body.pipe(fileStream);
+            res.body.on("error", reject);
+            fileStream.on("finish", resolve);
+        });
+        console.log(`Finished downloading`);
+        return res;
+    });
+}

package/bin/commands/env.js

@@ -0,0 +1,133 @@
+import { updateConfig, getConfig } from './config.js'
+import { Agent as HttpAgent } from 'http';
+import { Agent as HttpsAgent } from 'https';
+import yargsInteractive from 'yargs-interactive';
+
+const httpAgent = new HttpAgent({
+    rejectUnauthorized: false
+})
+
+const httpsAgent = new HttpsAgent({
+    rejectUnauthorized: false
+})
+
+export function getAgent(protocol) {
+    return protocol === 'http' ? httpAgent : httpsAgent;
+}
+
+export function envCommand() {
+    return {
+        command: 'env [env]',
+        describe: 'If environment is specified, changes the current environment to the environment specified, otherwise sets up the config for a new environment',
+        builder: (yargs) => {
+            return yargs
+                .positional('env', {
+                    describe: 'Environment'
+                })
+                .option('list', {
+                    alias: 'l',
+                    type: 'boolean',
+                    description: 'List all existing environments'
+                })
+                .option('users', {
+                    alias: 'u',
+                    type: 'boolean',
+                    description: 'List all users in environment, uses positional [env] if used, otherwise current env'
+                })
+        },
+        handler: (argv) => handleEnv(argv)
+    }
+}
+
+export async function setupEnv(argv) {
+    let env;
+    if (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');
+            env.protocol = 'https';
+        }
+    }
+    if (!env) {
+        console.log('Current environment not set, please set it')
+        await interactiveEnv(argv, {
+            environment: {
+                type: 'input'
+            },
+            interactive: {
+                default: true
+            }
+        })
+        env = getConfig().env[getConfig()?.current?.env];
+    }
+    return env;
+}
+
+async function handleEnv(argv) {
+    if (argv.users) {
+        let env = argv.env || getConfig().current.env;
+        console.log(`Users in environment ${env}: ${Object.keys(getConfig().env[env].users || {})}`);
+    } else if (argv.env) {
+        changeEnv(argv)
+    } else if (argv.list) {
+        console.log(`Existing environments: ${Object.keys(getConfig().env || {})}`)
+    } else {
+        interactiveEnv(argv, {
+            environment: {
+                type: 'input'
+            },
+            protocol: {
+                type: 'input'
+            },
+            host: {
+                type: 'input'
+            },
+            interactive: {
+                default: true
+            }
+        })
+    }
+}
+
+export async function interactiveEnv(argv, options) {
+    if (argv.verbose) console.info('Setting up new environment')
+    await yargsInteractive()
+        .interactive(options)
+        .then(async (result) => {
+            getConfig().env = getConfig().env || {};
+            getConfig().env[result.environment] = getConfig().env[result.environment] || {};
+            getConfig().env[result.environment].protocol = result.protocol || 'https';
+            if (result.host)
+                getConfig().env[result.environment].host = result.host;
+            if (result.environment) {
+                getConfig().current = getConfig().current || {};
+                getConfig().current.env = result.environment;
+            }
+            updateConfig();
+            console.log(`Your current environment is now ${getConfig().current.env}`);
+        });
+}
+
+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, {
+            environment: {
+                type: 'input',
+                default: argv.env,
+                prompt: 'never'
+            },
+            host: {
+                type: 'input',
+                prompt: 'always'
+            },
+            interactive: {
+                default: true
+            }
+        })
+    } else {
+        getConfig().current.env = argv.env;
+        updateConfig();
+        console.log(`Your current environment is now ${getConfig().current.env}`);
+    }
+}

package/bin/commands/files.js

@@ -0,0 +1,232 @@
+import fetch from 'node-fetch';
+import path from 'path';
+import fs from 'fs';
+import extract from 'extract-zip';
+import FormData from 'form-data';
+import { setupEnv, getAgent } from './env.js';
+import { setupUser } from './login.js';
+import { interactiveConfirm } from '../utils.js';
+
+export function filesCommand() {
+    return {
+        command: 'files [dirPath] [outPath]', 
+        describe: 'Handles files', 
+        builder: (yargs) => {
+            return yargs
+            .positional('dirPath', {
+                describe: 'The directory to list or export'
+            })
+            .positional('outPath', {
+                describe: 'The directory to export the specified directory to',
+                default: '.'
+            })
+            .option('list', {
+                alias: 'l',
+                type: 'boolean',
+                describe: 'Lists all directories and files'
+            })
+            .option('export', {
+                alias: 'e',
+                type: 'boolean',
+                describe: 'Exports the directory at [dirPath] to [outPath]'
+            })
+            .option('import', {
+                alias: 'i',
+                type: 'boolean',
+                describe: 'Imports the file at [dirPath] to [outPath]'
+            })
+            .option('includeFiles', {
+                alias: 'f',
+                type: 'boolean',
+                describe: 'Includes files in list of directories and files'
+            })
+            .option('recursive', {
+                alias: 'r',
+                type: 'boolean',
+                describe: 'Handles all directories recursively'
+            })
+            .option('raw', {
+                type: 'boolean',
+                describe: 'Keeps zip file instead of unpacking it'
+            })
+            .option('iamstupid', {
+                type: 'boolean',
+                describe: 'Includes export of log and cache folders, NOT RECOMMENDED'
+            })
+        },
+        handler: (argv) => {
+            if (argv.verbose) console.info(`Listing directory at: ${argv.dirPath}`)
+            handleFiles(argv)
+        }
+    }
+}
+
+async function handleFiles(argv) {
+    let env = await setupEnv(argv);
+    let user = await setupUser(argv, env);
+
+    if (argv.list) {
+        let files = (await getFilesStructure(env, user, argv.dirPath, argv.recursive, argv.includeFiles)).model;
+        console.log(files.name)
+        let hasFiles = files.files?.data && files.files?.data.length !== 0;
+        resolveTree(files.directories, '', hasFiles);
+        resolveTree(files.files?.data ?? [], '', false);
+    }
+
+    if (argv.export) {
+        if (argv.dirPath) {
+            await download(env, user, argv.dirPath, argv.outPath, argv.recursive, null, argv.raw, []);
+        } else {
+            await interactiveConfirm('Are you sure you want a full export of files?', async () => {
+                console.log('Full export is starting')
+                let filesStructure = (await getFilesStructure(env, user, '/', false, argv.includeFiles)).model;
+                let dirs = filesStructure.directories;
+                for (let id = 0; id < dirs.length; id++) {
+                    const dir = dirs[id];
+                    await download(env, user, dir.name, argv.outPath, true, null, argv.raw, argv.iamstupid, []);
+                }
+                await download(env, user, '/.', argv.outPath, false, 'Base.zip', argv.raw, argv.iamstupid, Array.from(filesStructure.files.data, f => f.name));
+                if (argv.raw) console.log('The files in the base "files" folder is in Base.zip, each directory in "files" is in its own zip')
+            })
+        }
+    } else if (argv.import) {
+        if (argv.dirPath && argv.outPath) {
+            let resolvedPath = path.resolve(argv.dirPath)
+            await uploadFile(env, user, resolvedPath, argv.outPath);
+        }
+    }
+}
+
+function resolveTree(dirs, indentLevel, parentHasFiles) {
+    let end = `└──`
+    let mid = `├──`
+    for (let id = 0; id < dirs.length; id++) {
+        const dir = dirs[id];
+        let indentPipe = true;
+        if (dirs.length == 1) {
+            if (parentHasFiles) {
+                console.log(indentLevel + mid, dir.name)
+            } else {
+                console.log(indentLevel + end, dir.name)
+                indentPipe = false;
+            }
+        } else if (id != dirs.length - 1) {
+            console.log(indentLevel + mid, dir.name)
+        } else {
+            if (parentHasFiles) {
+                console.log(indentLevel + mid, dir.name)
+            } else {
+                console.log(indentLevel + end, dir.name)
+                indentPipe = false;
+            }
+        }
+        let hasFiles = dir.files?.data && dir.files?.data.length !== 0;
+        if (indentPipe) {
+            resolveTree(dir.directories ?? [], indentLevel + '│\t', hasFiles);
+            resolveTree(dir.files?.data ?? [], indentLevel + '│\t', false);
+        } else {
+            resolveTree(dir.directories ?? [], indentLevel + '\t', hasFiles);
+            resolveTree(dir.files?.data ?? [], indentLevel + '\t', false);  
+        }
+    }
+}
+
+async function download(env, user, dirPath, outPath, recursive, outname, raw, iamstupid, fileNames) {
+    let endpoint;
+    let excludeDirectories = '';
+    if (!iamstupid) {
+        excludeDirectories = 'system/log';
+        if (dirPath === 'cache.net') {
+            return;
+        }
+    }
+    let data = {
+        'DirectoryPath': dirPath ?? '/',
+        'ExcludeDirectories': [ excludeDirectories ],
+    }
+
+    if (recursive) {
+        endpoint = 'DirectoryDownload';
+    } else {
+        endpoint = 'FileDownload'
+        data['Ids'] = fileNames
+    }
+
+    console.log('Downloading', dirPath === '/.' ? 'Base' : dirPath, 'Recursive=' + recursive);
+
+    let filename;
+    
+    fetch(`${env.protocol}://${env.host}/Admin/Api/${endpoint}`, {
+        method: 'POST',
+        body: JSON.stringify(data),
+        headers: {
+            'Authorization': `Bearer ${user.apiKey}`,
+            'Content-Type': 'application/json'
+        },
+        agent: getAgent(env.protocol)
+    }).then((res) => {
+        const header = res.headers.get('content-disposition');
+        const parts = header?.split(';');
+        if (!parts) {
+            console.log(`No files found in directory '${dirPath}', if you want to download all folders recursively include the -r flag`);
+            return;
+        }
+        filename = parts[1].split('=')[1].replace('+', ' ');
+        if (outname) filename = outname;
+        return res;
+    }).then(async (res) => {
+        if (!filename) return;
+        let filePath = path.resolve(`${path.resolve(outPath)}/${filename}`)
+        const fileStream = fs.createWriteStream(filePath);
+        await new Promise((resolve, reject) => {
+            res.body.pipe(fileStream);
+            res.body.on("error", reject);
+            fileStream.on("finish", resolve);
+        });
+        console.log(`Finished downloading`, dirPath === '/.' ? '.' : dirPath, 'Recursive=' + recursive);
+        if (!raw) {
+            let filenameWithoutExtension = filename.replace('.zip', '')
+            await extract(filePath, { dir: `${path.resolve(outPath)}/${filenameWithoutExtension === 'Base' ? '' : filenameWithoutExtension}` }, function (err) {})
+            fs.unlink(filePath, function(err) {})
+        }
+        return res;
+    });
+}
+
+async function getFilesStructure(env, user, dirPath, recursive, includeFiles) {
+    let res = await fetch(`${env.protocol}://${env.host}/Admin/Api/DirectoryAll?DirectoryPath=${dirPath ?? '/'}&recursive=${recursive ?? 'false'}&includeFiles=${includeFiles ?? 'false'}`, {
+        method: 'GET',
+        headers: {
+            'Authorization': `Bearer ${user.apiKey}`
+        },
+        agent: getAgent(env.protocol)
+    });
+    if (res.ok) {
+        return await res.json();
+    } else {
+        console.log(res);
+    }
+}
+
+export async function uploadFile(env, user, localFilePath, destinationPath) {
+    console.log('Uploading file')
+    let form = new FormData();
+    form.append('path', destinationPath);
+    form.append('files', fs.createReadStream(localFilePath));
+    let res = await fetch(`${env.protocol}://${env.host}/Admin/Api/Upload`, {
+        method: 'POST',
+        body: form,
+        headers: {
+            'Authorization': `Bearer ${user.apiKey}`
+        },
+        agent: getAgent(env.protocol)
+    });
+    if (res.ok) {
+        if (env.verbose) console.log(await res.json())
+        console.log(`File uploaded`)
+    }
+    else {
+        console.log(res)
+        return;
+    }
+}

package/bin/commands/install.js

@@ -0,0 +1,55 @@
+import fetch from 'node-fetch';
+import path from 'path';
+import { setupEnv, getAgent } from './env.js';
+import { setupUser } from './login.js';
+import { uploadFile } from './files.js';
+
+export function installCommand() {
+    return {
+        command: 'install [filePath]', 
+        describe: 'Installs the addin on the given path, allowed file extensions are .dll, .nupkg', 
+        builder: (yargs) => {
+            return yargs
+            .positional('filePath', {
+                describe: 'Path to the file to install'
+            })
+        },
+        handler: (argv) => {
+            if (argv.verbose) console.info(`Installing file located at :${argv.filePath}`)
+            handleInstall(argv)
+        }
+    }
+}
+
+async function handleInstall(argv) {
+    let env = await setupEnv(argv);
+    let user = await setupUser(argv, env);
+    let resolvedPath = path.resolve(argv.filePath)
+    await uploadFile(env, user, resolvedPath, 'System/AddIns/Local');
+    await installAddin(env, user, resolvedPath)
+}
+
+async function installAddin(env, user, resolvedPath) {
+    console.log('Installing addin')
+    let data = {
+        'AddinProvider': 'Dynamicweb.Marketplace.Providers.LocalAddinProvider',
+        'Package': path.basename(resolvedPath)
+    }
+    let res = await fetch(`${env.protocol}://${env.host}/Admin/Api/AddinInstall`, {
+        method: 'POST',
+        body: JSON.stringify(data),
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${user.apiKey}`
+        },
+        agent: getAgent(env.protocol)
+    });
+
+    if (res.ok) {
+        if (env.verbose) console.log(await res.json())
+        console.log(`Addin installed`)
+    }
+    else {
+        console.log(res)
+    }
+}

package/bin/commands/login.js

@@ -0,0 +1,190 @@
+import fetch from 'node-fetch';
+import { interactiveEnv, getAgent } from './env.js'
+import { updateConfig, getConfig } from './config.js';
+import yargsInteractive from 'yargs-interactive';
+
+export function loginCommand() {
+    return {
+        command: 'login [user]',
+        describe: 'If user is specified, changes the current user to the user specified, otherwise fetches an API-key that will be used to upload files and trigger addin installs, this runs with interactive mode',
+        builder: (yargs) => {
+            return yargs
+            .positional('user', {
+                describe: 'user'
+            })
+        },
+        handler: (argv) => handleLogin(argv)
+    }
+}
+
+export async function setupUser(argv, env) {
+    let user;
+    if (env.users) {
+        user = env.users[argv.user] || env.users[env.current.user];
+    }
+    if (!user) {
+        console.log('Current user not set, please login')
+        await interactiveLogin(argv, {
+            environment: {
+                type: 'input',
+                default: getConfig()?.current?.env,
+                prompt: 'never'
+              },
+              username: { 
+                type: 'input'
+              },
+              password: { 
+                type: 'password'
+              },
+              interactive: {
+                  default: true
+              }
+        })
+        user = env.users[env.current.user];
+    }
+    return user;
+}
+
+async function handleLogin(argv) {
+    argv.user ? changeUser(argv) : interactiveLogin(argv, {
+        environment: {
+            type: 'input',
+            default: getConfig()?.current?.env || 'dev',
+            prompt: 'if-no-arg'
+          },
+          username: { 
+            type: 'input'
+          },
+          password: { 
+            type: 'password'
+          },
+          interactive: {
+              default: true
+          }
+    })
+}
+
+export async function interactiveLogin(argv, options) {
+    if (argv.verbose) console.info('Now logging in')
+    await yargsInteractive()
+        .interactive(options)
+        .then(async (result) => {
+            if (!getConfig().env || !getConfig().env[result.environment] || !getConfig().env[result.environment].host || !getConfig().env[result.environment].protocol) {
+                if (!argv.host || !argv.protocol)
+                    console.log(`The environment specified is missing parameters, please specify them`)
+                await interactiveEnv(argv, {
+                    environment: {
+                        type: 'input',
+                        default: result.environment,
+                        prompt: 'never'
+                    },
+                    protocol: {
+                        type: 'input',
+                        prompt: 'if-no-arg'
+                    },
+                    host: {
+                        type: 'input',
+                        prompt: 'if-no-arg'
+                    },
+                    interactive: {
+                        default: true
+                    }
+                })
+            }
+            await loginInteractive(result);
+        });
+}
+
+async function loginInteractive(result) {
+    var protocol = getConfig().env[result.environment].protocol;
+    var token = await login(result.username, result.password, result.environment, protocol);
+    var apiKey = await getApiKey(token, result.environment, protocol)
+    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;
+    updateConfig();
+}
+
+async function login(username, password, env, protocol) {
+    let data = new URLSearchParams();
+    data.append('Username', username);
+    data.append('Password', password);
+    var res = await fetch(`${protocol}://${getConfig().env[env].host}/Admin/Authentication/Login`, {
+        method: 'POST',
+        body: data,
+        headers: {
+            'Content-Type': 'application/x-www-form-urlencoded'
+        },
+        agent: getAgent(protocol)
+    });
+
+    if (res.ok) {
+        let user = parseCookies(res.headers.get('set-cookie')).user;
+        return await getToken(user, env, protocol)
+    }
+    else {
+        console.log(res)
+    }
+}
+
+function parseCookies (cookieHeader) {
+    const list = {};
+    if (!cookieHeader) return list;
+
+    cookieHeader.replace('httponly, ', '').replace('Dynamicweb.Admin', 'user').split(`;`).forEach(cookie => {
+        let [ name, ...rest] = cookie.split(`=`);
+        name = name?.trim();
+        if (!name) return;
+        const value = rest.join(`=`).trim();
+        if (!value) return;
+        list[name] = decodeURIComponent(value);
+    });
+
+    return list;
+}
+
+async function getToken(user, env, protocol) {
+    var res = await fetch(`${getConfig().env[env].protocol}://${getConfig().env[env].host}/Admin/Authentication/Token`, {
+        method: 'GET',
+        headers: {
+            'cookie': `Dynamicweb.Admin=${user}`
+        },
+        agent: getAgent(protocol)
+    });
+    if (res.ok) {
+        return (await res.json()).token
+    }
+}
+
+async function getApiKey(token, env, protocol) {
+    let data = {
+        'Name': 'addin',
+        'Prefix': 'addin',
+        'Description': 'Auto-generated ApiKey by DW CLI'
+    };
+    var res = await fetch(`${protocol}://${getConfig().env[env].host}/Admin/Api/ApiKeySave`, {
+        method: 'POST',
+        body: JSON.stringify( { 'model': data } ),
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${token}`
+        },
+        agent: getAgent(protocol)
+    });
+
+    if (res.ok) {
+        return (await res.json()).message
+    }
+    else {
+        console.log(await res.json())
+    }
+}
+
+async function changeUser(argv) {
+    getConfig().env[getConfig().current.env].current.user = argv.user;
+    updateConfig();
+    console.log(`You're now logged in as ${getConfig().env[getConfig().current.env].current.user}`);
+}

package/bin/commands/query.js

@@ -0,0 +1,92 @@
+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()
+        return body.model.propertyNames
+    }
+    console.log(res)
+}
+
+async function getQueryParams(argv) {
+    let params = {}
+    if (argv.interactive) {
+        let props = { interactive: { default: true }}
+        Array.from(await getProperties(argv)).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}`)
+    }
+    return await res.json()
+}

package/bin/commands/swift.js

@@ -0,0 +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)
+        }
+    }
+}

package/bin/index.js

@@ -0,0 +1,48 @@
+#! /usr/bin/env node
+
+import yargs from 'yargs/yargs';
+import { hideBin } from 'yargs/helpers';
+import { loginCommand } from './commands/login.js';
+import { envCommand } from './commands/env.js';
+import { configCommand, setupConfig, getConfig } from './commands/config.js';
+import { installCommand } from './commands/install.js';
+import { filesCommand } from './commands/files.js';
+import { swiftCommand } from './commands/swift.js';
+import { databaseCommand } from './commands/database.js';
+import { queryCommand } from './commands/query.js';
+import { commandCommand } from './commands/command.js';
+
+setupConfig();
+
+yargs(hideBin(process.argv))
+    .scriptName('dw')
+    .command(baseCommand())
+    .command(loginCommand())
+    .command(envCommand())
+    .command(installCommand())
+    .command(configCommand())
+    .command(filesCommand())
+    .command(swiftCommand())
+    .command(databaseCommand())
+    .command(queryCommand())
+    .command(commandCommand())
+    .option('verbose', {
+        alias: 'v',
+        type: 'boolean',
+        description: 'Run with verbose logging'
+    })
+    .demandCommand()
+    .parse()
+
+function baseCommand() {
+    return {
+        command: '$0',
+        describe: 'Shows the current env and user being used',
+        handler: () => {
+            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}`)
+        }
+    }
+}

package/bin/utils.js

@@ -0,0 +1,20 @@
+import yargsInteractive from 'yargs-interactive';
+
+export async function interactiveConfirm(question, func) {
+    await yargsInteractive()
+        .interactive({
+            confirm: {
+                type: 'confirm',
+                default: false,
+                describe: question,
+                prompt: 'always'
+            },
+            interactive: {
+                default: true
+            }
+        })
+        .then(async (result) => {
+            if (!result.confirm) return;
+            func()
+        });
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@dynamicweb/cli",
+  "type": "module",
+  "description": "Dynamicweb CLI is a commandline tool for interacting with Dynamicweb 10 solutions.",
+  "version": "1.0.0",
+  "main": "bin/index.js",
+  "files": [
+    "bin/*"
+  ],
+  "keywords": [],
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "Dynamicweb A/S (https://www.dynamicweb.com)",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dynamicweb/CLI.git"
+  },
+  "contributors": [
+    "Dynamicweb A/S"
+  ],
+  "license": "MIT",
+  "bin": {
+    "dw": "bin/index.js"
+  },
+  "bugs": {
+    "url": "https://github.com/dynamicweb/CLI/issues"
+  },
+  "dependencies": {
+    "child_process": "^1.0.2",
+    "degit": "^2.8.4",
+    "extract-zip": "^2.0.1",
+    "fetch": "^1.1.0",
+    "form-data": "^4.0.0",
+    "https": "^1.0.0",
+    "node-fetch": "^3.2.10",
+    "path": "^0.12.7",
+    "yargs": "^17.5.1",
+    "yargs-interactive": "^3.0.1"
+  }
+}