contensis-cli 1.0.0-beta.5

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "contensis-cli",
+  "version": "1.0.0-beta.5",
+  "description": "A fully featured Contensis command line interface with a shell UI provides simple and intuitive ways to manage or profile your content in any NodeJS terminal.",
+  "repository": "https://github.com/contensis/node-cli",
+  "homepage": "https://github.com/contensis/node-cli/tree/main/packages/contensis-cli#readme",
+  "main": "dist/index.js",
+  "bin": {
+    "contensis": "./cli.js",
+    "contensis-cli": "./cli.js"
+  },
+  "scripts": {
+    "prestart": "npm run build",
+    "start": "npm run cli",
+    "dev:shell": "npm run prestart && nodemon --watch dist --inspect=9229 ./dist/shell.js",
+    "prebuild": "node -p \"'export const LIB_VERSION = ' + JSON.stringify(require('./package.json').version) + ';'\" > src/version.ts",
+    "build": "node esbuild.config.js",
+    "build:watch": "node esbuild.config.js --watch",
+    "cli": "node --inspect=9229 ./cli.js",
+    "postinstall": "npx patch-package",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "Zengenti",
+  "license": "ISC",
+  "dependencies": {
+    "app-root-path": "^3.1.0",
+    "chalk": "^4.1.2",
+    "commander": "^9.4.1",
+    "csv": "^6.1.0",
+    "dayjs": "^1.11.6",
+    "figlet": "^1.5.2",
+    "flat": "^5.0.2",
+    "inquirer-command-prompt": "^0.1.0",
+    "json2csv": "^5.0.7",
+    "jsonpath-mapper": "^1.1.0",
+    "keytar": "^7.9.0",
+    "lodash": "^4.17.21",
+    "migratortron": "^1.0.0-beta.14",
+    "node-fetch": "^2.6.7",
+    "patch-package": "^6.4.7",
+    "xml2js": "^0.4.23"
+  },
+  "devDependencies": {
+    "@types/figlet": "^1.5.4",
+    "@types/flat": "^5.0.2",
+    "@types/inquirer": "^8.2.1",
+    "@types/json2csv": "^5.0.3",
+    "@types/lodash": "^4.14.182",
+    "@types/node-fetch": "^2.6.1",
+    "@types/xml2js": "^0.4.11",
+    "esbuild": "^0.14.43",
+    "esbuild-node-externals": "^1.4.1",
+    "esbuild-plugin-glob": "^1.1.2",
+    "nodemon": "^2.0.18",
+    "rimraf": "^3.0.2",
+    "tsc-alias": "^1.6.9",
+    "typescript": "^4.7.3"
+  }
+}

package/patches/inquirer-command-prompt+0.1.0.patch

@@ -0,0 +1,27 @@
+diff --git a/node_modules/inquirer-command-prompt/index.js b/node_modules/inquirer-command-prompt/index.js
+index 9192101..6c1133f 100644
+--- a/node_modules/inquirer-command-prompt/index.js
++++ b/node_modules/inquirer-command-prompt/index.js
+@@ -46,7 +46,7 @@ class CommandPrompt extends InputPrompt {
+   }
+ 
+   async initAutoCompletion(context, autoCompletion) {
+-    if (!autoCompleters[context]) {
++    // if (!autoCompleters[context]) {
+       if (thiz.isAsyncFunc(autoCompletion)) {
+         autoCompleters[context] = async l => this.asyncAutoCompleter(l, autoCompletion)
+       } else if (autoCompletion) {
+@@ -54,7 +54,7 @@ class CommandPrompt extends InputPrompt {
+       } else {
+         autoCompleters[context] = () => []
+       }
+-    }
++    // }
+   }
+ 
+   static addToHistory(context, value) {
+@@ -394,4 +394,3 @@ class CommandPrompt extends InputPrompt {
+ let thiz = CommandPrompt
+ 
+ module.exports = CommandPrompt
+-

package/src/commands/connect.ts

@@ -0,0 +1,23 @@
+import { Command } from 'commander';
+import { cliCommand } from '~/services/ContensisCliService';
+import { shell } from '~/shell';
+import { project } from './globalOptions';
+
+export const makeConnectCommand = () => {
+  const connect = new Command()
+    .command('connect')
+    .argument('<alias>', 'the Contensis Cloud alias to connect with')
+    .addOption(project)
+    .usage('<alias>')
+    .addHelpText(
+      'after',
+      `
+Example call:
+  > connect example-dev`
+    )
+    .action(async (alias, opts) => {
+      await cliCommand(['connect', alias], opts).Connect(alias);
+      await shell().start();
+    });
+  return connect;
+};

package/src/commands/create.ts

@@ -0,0 +1,41 @@
+import { Command } from 'commander';
+import { cliCommand } from '~/services/ContensisCliService';
+import { shell } from '~/shell';
+
+export const makeCreateCommand = () => {
+  const create = new Command()
+    .command('create')
+    .showHelpAfterError(true)
+    .exitOverride();
+
+  create
+    .command('project')
+    .argument('<projectId>', 'the id of the project to create')
+    .usage('<projectId>')
+    .action(async (projectId: string, opts: any) => {
+      const project = await cliCommand(
+        ['create', 'project', projectId],
+        opts
+      ).SetProject(projectId);
+      if (project) await shell().start();
+    });
+  create
+    .command('key')
+    .argument('<"key name">', 'the name of the key to create')
+    .argument('["description"]', 'provide a description for the key (optional)')
+    .usage('<"key name"> ["description"] (both args in "double quotes")')
+    .addHelpText(
+      'after',
+      `
+Example call:
+  > create key "my new key" "Created key for demonstration"\n`
+    )
+    .action(async (name: string, description: string, opts: any) => {
+      await cliCommand(['create', 'key', name], opts).CreateApiKey(
+        name,
+        description
+      );
+    });
+
+  return create;
+};

package/src/commands/get.ts

@@ -0,0 +1,139 @@
+import { Argument, Command } from 'commander';
+import { cliCommand } from '~/services/ContensisCliService';
+import { mapContensisOpts } from './globalOptions';
+
+export const makeGetCommand = () => {
+  const program = new Command()
+    .command('get')
+    .showHelpAfterError(true)
+    .exitOverride();
+
+  program
+    .command('contenttype')
+    .argument('<contentTypeId>', 'the API id of the content type to get')
+    .addHelpText(
+      'after',
+      `
+Example call:
+  > get contenttype {contentTypeId} -o content-type-backup.json
+`
+    )
+    .action(async (contentTypeId: string, opts) => {
+      await cliCommand(['get', 'contenttype'], opts).PrintContentType(
+        contentTypeId
+      );
+    });
+  program
+    .command('component')
+    .argument('<componentId>', 'the API id of the component to get')
+    .addHelpText(
+      'after',
+      `
+Example call:
+  > get component {componentId} -o component-backup.json
+`
+    )
+    .action(async (componentId: string, opts) => {
+      await cliCommand(['get', 'component'], opts).PrintComponent(componentId);
+    });
+  program
+    .command('entries')
+    .argument(
+      '[search phrase]',
+      'get entries with the search phrase, use quotes for multiple words'
+    )
+    .option('-i --id <id...>', 'the entry id to get')
+    .option(
+      '-d, --dependents',
+      'find and return any dependencies of all found entries'
+    )
+    .option(
+      '-fi, --fields <fields...>',
+      'limit the output fields on returned entries'
+    )
+    .option(
+      '-q, --zenql <zenql>',
+      'get entries with a supplied ZenQL statement'
+    )
+    .addHelpText(
+      'after',
+      `
+Example call:
+  > get entries --zenql "sys.contentTypeId = blog" --fields entryTitle entryDescription sys.id --output ./blog-posts.csv --format csv
+`
+    )
+    .action(async (phrase: string, opts, cmd) => {
+      // console.log('phrase: ', phrase, '\nopts:', JSON.stringify(opts, null, 2));
+      // console.log('opts:', JSON.stringify(opts, null, 2));
+      await cliCommand(
+        ['get', 'entries'],
+        opts,
+        mapContensisOpts({ phrase, ...opts })
+      ).GetEntries({
+        withDependents: opts.dependents,
+      });
+    });
+
+  const block = program
+    .command('block')
+    .argument('[blockId]', 'the block to get version details for')
+    .argument(
+      '[branch]',
+      'the branch of the block to get version details for',
+      'main'
+    )
+    .argument(
+      '[version]',
+      'get a specific version of the block pushed to the specified branch'
+    )
+    .action(async (blockId: string, branch: string, version: string, opts) => {
+      await cliCommand(['get', 'block'], opts).PrintBlockVersions(
+        blockId,
+        branch,
+        version
+      );
+    });
+
+  const dataCenter = new Argument(
+    '[dataCenter]',
+    'the datacentre of the block to get logs for'
+  )
+    .choices(['hq', 'london', 'manchester'])
+    .default('hq');
+
+  block
+    .command('logs')
+    .argument('[blockId]', 'the block to get version logs for')
+    .argument(
+      '[branch]',
+      'the branch of the block to get version details for',
+      'main'
+    )
+    .argument(
+      '[version]',
+      'the version of the block pushed to the branch to get logs for',
+      'latest'
+    )
+    .addArgument(dataCenter)
+    .usage('get block logs [blockId] [branch] [version] [dataCenter]')
+    .action(
+      async (
+        blockId: string,
+        branch: string,
+        version: string,
+        dataCenter: 'hq' | 'manchester' | 'london',
+        opts
+      ) => {
+        await cliCommand(['get', 'block', 'logs'], opts).PrintBlockLogs(
+          blockId,
+          branch,
+          version,
+          dataCenter
+        );
+      }
+    );
+
+  return program;
+};
+
+export const get = makeGetCommand();

package/src/commands/globalOptions.ts

@@ -0,0 +1,126 @@
+import { Command, Option } from 'commander';
+import { url } from '~/util';
+
+export const mapContensisOpts = (opts: any = {}) => ({
+  source:
+    opts.sourceCms || opts.sourceProjectId
+      ? {
+          url: opts.sourceCms
+            ? url(opts.sourceCms, 'website').cms
+            : (undefined as any),
+          project: opts.sourceProjectId || (undefined as any),
+        }
+      : undefined,
+  query:
+    opts.id || opts.phrase || opts.fields
+      ? {
+          fields: opts.fields,
+          includeIds: opts.id,
+          searchTerm: opts.phrase,
+        }
+      : undefined,
+  zenQL: opts.zenql,
+  transformGuids: !opts.preserveGuids,
+});
+
+/* Output options */
+const output = new Option(
+  '-o, --output <output>',
+  'save output to a file e.g. --output ./output.txt'
+);
+
+const format = new Option(
+  '-f, --format <format>',
+  'format output as csv, json, xml or table (default)'
+).choices(['csv', 'json', 'xml', 'table']);
+
+/* Connect options */
+const alias = new Option(
+  '-a --alias <alias>',
+  'the cloud CMS alias to connect your request with'
+);
+
+export const project = new Option(
+  '-p --project-id <projectId>',
+  'the projectId to make your request with'
+);
+
+/* Authentication options */
+const user = new Option(
+  '-u --user <user>',
+  'the username to authenticate your request with'
+);
+const password = new Option(
+  '-pw --password <password>',
+  'the password to use to login with (optional/insecure)'
+);
+const clientId = new Option(
+  '-id --client-id <clientId>',
+  'the clientId to authenticate your request with'
+);
+const sharedSecret = new Option(
+  '-s --shared-secret <sharedSecret>',
+  'the shared secret to use when logging in with a client id'
+);
+
+/* Entry get options */
+const zenql = new Option(
+  '-q, --zenql <zenql>',
+  'get entries with a supplied ZenQL statement'
+);
+
+const entryId = new Option('-i --id <id...>', 'the entry id to get');
+
+/* Import options */
+export const fromFile = new Option(
+  '-file --from-file <fromFile>',
+  'file path to import asset(s) from'
+);
+
+export const fromCms = new Option(
+  '-source --source-alias <fromCms>',
+  'the cloud CMS alias to import asset(s) from'
+);
+export const fromProject = new Option(
+  '-sp --source-project-id <fromProject>',
+  'the id of the Contensis project to import asset(s) from (Default: [last connected project])'
+);
+
+export const commit = new Option(
+  '--commit',
+  'omit and only add this flag when you are happy with the preview of the import'
+).default(false);
+
+export const addConnectOptions = (program: Command) =>
+  program.addOption(alias.hideHelp()).addOption(project.hideHelp());
+
+export const addAuthenticationOptions = (program: Command) =>
+  program
+    .addOption(user.hideHelp())
+    .addOption(password.hideHelp())
+    .addOption(clientId.hideHelp())
+    .addOption(sharedSecret.hideHelp());
+
+const addOutputAndFormatOptions = (program: Command) =>
+  program.addOption(output).addOption(format);
+
+export const addImportOptions = (program: Command) => {
+  for (const command of program.commands) {
+    command.addOption(fromFile).addOption(fromCms).addOption(fromProject);
+  }
+  return program;
+};
+export const addGetEntryOptions = (program: Command) => {
+  for (const command of program.commands) {
+    command.addOption(entryId).addOption(zenql);
+  }
+  return program;
+};
+export const addGlobalOptions = (program: Command) => {
+  for (const command of program.commands) {
+    addOutputAndFormatOptions(command);
+    addConnectOptions(command);
+    addAuthenticationOptions(command);
+  }
+  return program;
+};

package/src/commands/import.ts

@@ -0,0 +1,89 @@
+import { Argument, Command } from 'commander';
+import { cliCommand } from '~/services/ContensisCliService';
+import { url } from '~/util';
+import { commit, mapContensisOpts } from './globalOptions';
+
+export const makeImportCommand = () => {
+  const program = new Command()
+    .command('import')
+    .showHelpAfterError(true)
+    .exitOverride();
+
+  program
+    .command('contenttypes')
+    .argument(
+      '[contentTypeIds]',
+      'Optional list of API id(s) of the content type(s) to import'
+    )
+    .addHelpText(
+      'after',
+      `
+Example call:
+  > import contenttypes {contentTypeIds} --from-file contenttypes-backup.json
+  > import contenttypes {contentTypeIds} --source-alias example-dev
+`
+    )
+    .action(async (contentTypeIds: string[], opts) => {
+      await cliCommand(['import', 'contenttypes'], opts).ImportContentTypes(
+        {
+          fromFile: opts.fromFile,
+          commit: opts.commit,
+        },
+        contentTypeIds
+      );
+    });
+
+  program
+    .command('components')
+    .argument(
+      '[componentIds]',
+      'Optional list of API id(s) of the component(s) to import'
+    )
+    .addHelpText(
+      'after',
+      `
+Example call:
+  > import components {componentIds} --from-file component-backup.json
+  > import components {componentIds} --source-alias example-dev
+`
+    )
+    .action(async (componentIds: string[], opts) => {
+      await cliCommand(['import', 'component'], opts).ImportComponents(
+        {
+          fromFile: opts.fromFile,
+          commit: opts.commit,
+        },
+        componentIds
+      );
+    });
+
+  program
+    .command('entries')
+    .argument(
+      '[search phrase]',
+      'get entries with the search phrase, use quotes for multiple words'
+    )
+    .addOption(commit)
+    .option(
+      '-preserve, --preserve-guids',
+      'include this flag when you are importing entries that you have previously exported and wish to update'
+    )
+    .addHelpText(
+      'after',
+      `
+Example call:
+  > import entries --source-cms example-dev --source-project-id microsite --zenql "sys.contentTypeId = blog"
+`
+    )
+    .action(async (phrase: string, opts, cmd) => {
+      await cliCommand(
+        ['import', 'entries'],
+        opts,
+        mapContensisOpts({ phrase, ...opts })
+      ).ImportEntries({ commit: opts.commit, fromFile: opts.fromFile });
+    });
+
+  return program;
+};
+
+export const get = makeImportCommand();

package/src/commands/index.ts

@@ -0,0 +1,72 @@
+import { Command } from 'commander';
+import { Logger } from '~/util/logger';
+import { LIB_VERSION } from '~/version';
+import { makeConnectCommand } from './connect';
+import { makeCreateCommand } from './create';
+import { makeGetCommand } from './get';
+import {
+  addAuthenticationOptions,
+  addConnectOptions,
+  addGetEntryOptions,
+  addGlobalOptions,
+  addImportOptions,
+} from './globalOptions';
+import { makeImportCommand } from './import';
+import { makeListCommand } from './list';
+import { makeLoginCommand } from './login';
+import { makePushCommand } from './push';
+import { makeRemoveCommand } from './remove';
+import { makeSetCommand } from './set';
+
+const commands = () => {
+  const program = new Command()
+    .name('contensis')
+    .version(LIB_VERSION)
+    .configureOutput({
+      writeErr: str => {
+        return str.toLowerCase().includes('error')
+          ? Logger.error(`Command ${str}`)
+          : str.trim() && Logger.help(str);
+      },
+    })
+    .exitOverride()
+    .showHelpAfterError(true);
+
+  program.addCommand(
+    addAuthenticationOptions(makeConnectCommand()).copyInheritedSettings(
+      program
+    )
+  );
+  program.addCommand(
+    addGlobalOptions(
+      addImportOptions(makeCreateCommand())
+    ).copyInheritedSettings(program)
+  );
+  program.addCommand(
+    addGlobalOptions(makeGetCommand()).copyInheritedSettings(program)
+  );
+  program.addCommand(
+    addGlobalOptions(
+      addGetEntryOptions(addImportOptions(makeImportCommand()))
+    ).copyInheritedSettings(program)
+  );
+  program.addCommand(
+    addGlobalOptions(makeListCommand()).copyInheritedSettings(program)
+  );
+  program.addCommand(
+    addConnectOptions(makeLoginCommand()).copyInheritedSettings(program)
+  );
+  program.addCommand(
+    addGlobalOptions(makePushCommand()).copyInheritedSettings(program)
+  );
+  program.addCommand(
+    addGlobalOptions(makeRemoveCommand()).copyInheritedSettings(program)
+  );
+  program.addCommand(
+    addConnectOptions(makeSetCommand()).copyInheritedSettings(program)
+  );
+
+  return program;
+};
+
+export default commands;

package/src/commands/list.ts

@@ -0,0 +1,90 @@
+import { Command } from 'commander';
+import { cliCommand } from '~/services/ContensisCliService';
+
+// projects
+// content types
+// components
+// api keys
+// roles
+// webhooks
+export const makeListCommand = () => {
+  const list = new Command()
+    .command('list')
+    .showHelpAfterError(true)
+    .exitOverride();
+
+  list
+    .command('envs')
+    .addHelpText(
+      'after',
+      `
+Example call:
+  > list envs
+`
+    )
+    .action(opts => {
+      cliCommand(['list', 'envs'], opts).PrintEnvironments();
+    });
+  list.command('projects').action(async opts => {
+    await cliCommand(['list', 'projects'], opts).PrintProjects();
+  });
+  list
+    .command('contenttypes')
+    .addHelpText(
+      'after',
+      `
+Example call:
+  > list contenttypes -o ./output.json -f json
+`
+    )
+    .action(async opts => {
+      await cliCommand(['list', 'contenttypes'], opts).PrintContentTypes();
+    });
+  list
+    .command('components')
+    .addHelpText(
+      'after',
+      `
+Example call:
+  > list components -o ./output.json -f json
+`
+    )
+    .action(async opts => {
+      await cliCommand(['list', 'components'], opts).PrintComponents();
+    });
+  list
+    .command('blocks')
+    .addHelpText(
+      'after',
+      `
+Example call:
+  > list blocks
+`
+    )
+    .action(async opts => {
+      await cliCommand(['list', 'blocks'], opts).PrintBlocks();
+    });
+  list
+    .command('keys')
+    .addHelpText(
+      'after',
+      `
+Example call:
+  > list keys
+`
+    )
+    .action(async opts => {
+      await cliCommand(['list', 'keys'], opts).PrintApiKeys();
+    });
+  list
+    .command('webhooks')
+    .argument('[name]', 'find webhooks matching the supplied name')
+    .option('-i --id <id...>', 'the subscription id(s) to get')
+    .action(async (name?: string, { id, ...opts }: any = {}) => {
+      await cliCommand(['list', 'webhooks'], opts).PrintWebhookSubscriptions(
+        id,
+        name
+      );
+    });
+  return list;
+};