contensis-cli 1.0.0-beta.9 → 1.0.0-beta.90

package/src/commands/get.ts

@@ -1,15 +1,124 @@
-import { Argument, Command } from 'commander';
+import { Argument, Command, Option } from 'commander';
+import { merge } from 'lodash';
 import { cliCommand } from '~/services/ContensisCliService';
-import { mapContensisOpts } from './globalOptions';
+import {
+  addGlobalOptions,
+  assetTypes,
+  contentTypes,
+  entryId,
+  mapContensisOpts,
+  zenql,
+} from './globalOptions';
 
 export const makeGetCommand = () => {
   const program = new Command()
     .command('get')
+    .description('get command')
+    .addHelpText('after', `\n`)
     .showHelpAfterError(true)
     .exitOverride();
 
+  program
+    .command('version')
+    .description('get current Contensis version')
+    .addHelpText(
+      'after',
+      `
+Example call:
+  > version
+`
+    )
+    .action(async opts => {
+      await cliCommand(['get', 'version'], opts).PrintContensisVersion();
+    });
+
+  program
+    .command('token')
+    .description('show a bearer token for the currently logged in user')
+    .addHelpText(
+      'after',
+      `
+Example call:
+  > get token
+`
+    )
+    .action(async opts => {
+      await cliCommand(['get', 'token'], opts).PrintBearerToken();
+    });
+
+  program
+    .command('project')
+    .description('get a project')
+    .argument('[projectId]', 'id of the project to get (default: current)')
+    .addHelpText(
+      'after',
+      `
+Example call:
+  > get project website
+`
+    )
+    .action(async (projectId: string, opts) => {
+      await cliCommand(['get', 'project', projectId], opts).PrintProject(
+        projectId
+      );
+    });
+
+  program
+    .command('role')
+    .description('get a role')
+    .argument('<roleNameOrId>', 'id or name of the role to get')
+    .addHelpText(
+      'after',
+      `
+Example call:
+  > get role "entry admin"
+`
+    )
+    .action(async (roleNameOrId: string, opts) => {
+      await cliCommand(['get', 'role', roleNameOrId], opts).PrintRole(
+        roleNameOrId
+      );
+    });
+
+  program
+    .command('webhook')
+    .description('get a webhook')
+    .argument('<webhookNameOrId...>', 'id or name of the webhook(s) to get')
+    .addHelpText(
+      'after',
+      `
+Example call:
+  > get webhook "Slack notification"
+`
+    )
+    .action(async (webhookNameOrId: string[], opts) => {
+      await cliCommand(
+        ['get', 'webhook', webhookNameOrId.join(' ')],
+        opts
+      ).PrintWebhookSubscriptions(webhookNameOrId);
+    });
+
+  program
+    .command('model')
+    .description('get a content model')
+    .argument('<contentTypeId...>', 'ids of the content models to get')
+    .addHelpText(
+      'after',
+      `
+Example call:
+  > get model podcast podcastLinks
+`
+    )
+    .action(async (modelIds: string[], opts) => {
+      await cliCommand(
+        ['get', 'model', modelIds.join(' ')],
+        opts
+      ).PrintContentModels(modelIds);
+    });
+
   program
     .command('contenttype')
+    .description('get a content type')
     .argument('<contentTypeId>', 'the API id of the content type to get')
     .addHelpText(
       'after',
@@ -19,12 +128,15 @@ Example call:
 `
     )
     .action(async (contentTypeId: string, opts) => {
-      await cliCommand(['get', 'contenttype'], opts).PrintContentType(
-        contentTypeId
-      );
+      await cliCommand(
+        ['get', 'contenttype', contentTypeId],
+        opts
+      ).PrintContentType(contentTypeId);
     });
+
   program
     .command('component')
+    .description('get a component')
     .argument('<componentId>', 'the API id of the component to get')
     .addHelpText(
       'after',
@@ -34,32 +146,84 @@ Example call:
 `
     )
     .action(async (componentId: string, opts) => {
-      await cliCommand(['get', 'component'], opts).PrintComponent(componentId);
+      await cliCommand(['get', 'component', componentId], opts).PrintComponent(
+        componentId
+      );
+    });
+
+  const sharedGetEntryOptions = (command: Command) =>
+    command
+      .addOption(entryId)
+      .addOption(zenql)
+      .addOption(
+        new Option(
+          '-fi --fields <fields...>',
+          'limit the output fields on returned entries'
+        )
+      )
+      .addOption(
+        new Option(
+          '-ob --order-by <orderBy...>',
+          'field name(s) to order the results by (prefix "-" for descending)'
+        )
+      );
+
+  sharedGetEntryOptions(
+    program
+      .command('assets')
+      .description('get asset entries')
+      .argument(
+        '[search phrase]',
+        'get assets with the search phrase, use quotes for multiple words'
+      )
+      .addOption(assetTypes)
+  )
+    .option('-l --paths <paths...>', 'get assets under the given path(s)')
+    .addHelpText(
+      'after',
+      `
+Example call:
+  > get assets --zenql "sys.contentTypeId = blog" --fields sys.id sys.properties.filePath sys.properties.filename
+`
+    )
+    .action(async (phrase: string, opts) => {
+      // Maintaining a separate command for assets vs entries
+      // allows us to offer up more options when dealing with just assets
+      await cliCommand(
+        ['get', 'assets'],
+        opts,
+        mapContensisOpts({ dataFormat: 'asset', phrase, ...opts })
+      ).GetEntries({});
     });
+
+  sharedGetEntryOptions(
   program
     .command('entries')
+    .description('get entries')
     .argument(
       '[search phrase]',
       'get entries with the search phrase, use quotes for multiple words'
     )
-    .option('-i --id <id...>', 'the entry id to get')
+      .addOption(contentTypes)
     .option(
-      '-d, --dependents',
+        '-d --dependents',
       'find and return any dependencies of all found entries'
     )
-    .option(
-      '-fi, --fields <fields...>',
-      'limit the output fields on returned entries'
+  )
+    .addOption(
+      new Option(
+        '--data-format <dataFormat>',
+        'find and return entries of a specific data format'
     )
-    .option(
-      '-q, --zenql <zenql>',
-      'get entries with a supplied ZenQL statement'
+        .choices(['entry', 'asset', 'webpage'])
+        .default('entry')
     )
     .addHelpText(
       'after',
       `
 Example call:
   > get entries --zenql "sys.contentTypeId = blog" --fields entryTitle entryDescription sys.id --output ./blog-posts.csv --format csv
+  > get entries --content-type blog --fields entryTitle sys.version.modified --order-by -sys.version.modified
 `
     )
     .action(async (phrase: string, opts, cmd) => {
@@ -74,65 +238,115 @@ Example call:
       });
     });
 
+  program
+    .command('nodes')
+    .description('get nodes')
+    .argument('[root]', 'get node(s) from the specified path e.g. /blog', '/')
+    .option(
+      '-d --depth <depth>',
+      'get nodes with children to a specified depth',
+      '0'
+    )
+    .addHelpText(
+      'after',
+      `
+Example call:
+  > get nodes /blog --depth 1
+`
+    )
+    .action(async (root: string, opts) => {
+      await cliCommand(['get', 'nodes'], opts, mapContensisOpts(opts)).GetNodes(
+        root,
+        opts.depth
+      );
+    });
+
   const block = program
     .command('block')
+    .description('get a block or block version')
     .argument('[blockId]', 'the block to get version details for')
     .argument(
       '[branch]',
       'the branch of the block to get version details for',
-      'main'
+      'default'
     )
     .argument(
       '[version]',
       'get a specific version of the block pushed to the specified branch'
     )
+    .addHelpText(
+      'after',
+      `
+Example call:
+  > get block contensis-website
+  > get block contensis-website develop latest
+`
+    )
     .action(async (blockId: string, branch: string, version: string, opts) => {
-      await cliCommand(['get', 'block'], opts).PrintBlockVersions(
+      await cliCommand(['get', 'block', blockId], 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')
+    .description('get logs for a block')
     .argument('[blockId]', 'the block to get version logs for')
     .argument(
       '[branch]',
       'the branch of the block to get version details for',
-      'main'
+      'default'
     )
     .argument(
       '[version]',
       'the version of the block pushed to the branch to get logs for',
       'latest'
     )
-    .addArgument(dataCenter)
+    .addArgument(
+      new Argument(
+        '[dataCenter]',
+        'the datacentre of the block to get logs for'
+      )
+        .choices(['hq', 'london', 'manchester', 'all'])
+        .default('all')
+    )
+    .option('-t --follow', 'follow block logs in near realtime', false)
     .usage('get block logs [blockId] [branch] [version] [dataCenter]')
+    .addHelpText(
+      'after',
+      `
+Example call:
+  > get block logs contensis-website default
+  > get block logs contensis-website master latest london --follow
+`
+    )
     .action(
       async (
         blockId: string,
         branch: string,
         version: string,
-        dataCenter: 'hq' | 'manchester' | 'london',
+        dataCenter: 'hq' | 'manchester' | 'london' | 'all',
         opts
       ) => {
-        await cliCommand(['get', 'block', 'logs'], opts).PrintBlockLogs(
+        const parentOpts = block.opts() || {};
+        await cliCommand(
+          ['get', 'block', 'logs'],
+          merge(opts, parentOpts)
+        ).PrintBlockLogs(
           blockId,
           branch,
           version,
-          dataCenter
+          dataCenter === 'all' ? undefined : dataCenter,
+          opts.follow as boolean
         );
       }
     );
 
+  // Add global opts for inner sub-commands
+  addGlobalOptions(block);
+
   return program;
 };
 

package/src/commands/globalOptions.ts

@@ -3,19 +3,33 @@ import { url } from '~/util';
 
 export const mapContensisOpts = (opts: any = {}) => ({
   source:
-    opts.sourceCms || opts.sourceProjectId
+    opts.sourceAlias || opts.sourceProjectId
       ? {
-          url: opts.sourceCms
-            ? url(opts.sourceCms, 'website').cms
+          url: opts.sourceAlias
+            ? url(opts.sourceAlias, 'website').cms
             : (undefined as any),
           project: opts.sourceProjectId || (undefined as any),
         }
       : undefined,
+  models: opts.modelIds,
   query:
-    opts.id || opts.phrase || opts.fields
+    opts.id ||
+    opts.entryIds ||
+    opts.phrase ||
+    opts.fields ||
+    opts.orderBy ||
+    opts.paths ||
+    opts.assetType ||
+    opts.contentType ||
+    opts.dataFormat
       ? {
+          assetTypes: opts.assetType,
+          contentTypeIds: opts.contentType,
+          dataFormats: opts.dataFormat ? [opts.dataFormat] : undefined,
           fields: opts.fields,
-          includeIds: opts.id,
+          includeIds: opts.id || opts.entryIds,
+          includePaths: opts.paths,
+          orderBy: opts.orderBy,
           searchTerm: opts.phrase,
         }
       : undefined,
@@ -25,12 +39,12 @@ export const mapContensisOpts = (opts: any = {}) => ({
 
 /* Output options */
 const output = new Option(
-  '-o, --output <output>',
+  '-o --output <output>',
   'save output to a file e.g. --output ./output.txt'
 );
 
 const format = new Option(
-  '-f, --format <format>',
+  '-f --format <format>',
   'format output as csv, json, xml or table (default)'
 ).choices(['csv', 'json', 'xml', 'table']);
 
@@ -64,12 +78,20 @@ const sharedSecret = new Option(
 );
 
 /* Entry get options */
-const zenql = new Option(
-  '-q, --zenql <zenql>',
+export 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');
+export const entryId = new Option('-i --id <id...>', 'the entry id(s) to get');
+export const contentTypes = new Option(
+  '-c --content-type <contentType...>',
+  'get entries of these content type(s)'
+);
+export const assetTypes = new Option(
+  '-at --asset-type <assetType...>',
+  'get assets of given content type(s) e.g. image word pdf'
+);
 
 /* Import options */
 export const fromFile = new Option(
@@ -88,7 +110,7 @@ export const fromProject = new Option(
 
 export const commit = new Option(
   '--commit',
-  'omit and only add this flag when you are happy with the preview of the import'
+  'add this flag only after you have run a preview of the import and agree with the analysis'
 ).default(false);
 
 export const addConnectOptions = (program: Command) =>
@@ -110,9 +132,17 @@ export const addImportOptions = (program: Command) => {
   }
   return program;
 };
+
+export const getEntryOptions = (command: Command) =>
+  command
+    .addOption(entryId)
+    .addOption(zenql)
+    .addOption(contentTypes)
+    .addOption(assetTypes);
+
 export const addGetEntryOptions = (program: Command) => {
   for (const command of program.commands) {
-    command.addOption(entryId).addOption(zenql);
+    getEntryOptions(command);
   }
   return program;
 };

package/src/commands/import.ts

@@ -1,20 +1,47 @@
-import { Argument, Command } from 'commander';
+import { Command, Option } 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')
+    .description('import command')
+    .addHelpText('after', `\n`)
     .showHelpAfterError(true)
     .exitOverride();
 
+  program
+    .command('models')
+    .description('import complete content models')
+    .argument('[modelIds...]', 'ids of the content models to import (optional)')
+    .addOption(commit)
+    .addHelpText(
+      'after',
+      `
+Example call:
+  > import models blogPost --from-file contentmodels-backup.json
+  > import models --source-alias example-dev
+`
+    )
+    .action(async (modelIds: string[], opts) => {
+      await cliCommand(
+        ['import', 'models', modelIds.join(' ')],
+        opts,
+        mapContensisOpts({ modelIds, ...opts })
+      ).ImportContentModels({
+        fromFile: opts.fromFile,
+        commit: opts.commit,
+      });
+    });
+
   program
     .command('contenttypes')
+    .description('import content types')
     .argument(
-      '[contentTypeIds]',
+      '[contentTypeIds...]',
       'Optional list of API id(s) of the content type(s) to import'
     )
+    .addOption(commit)
     .addHelpText(
       'after',
       `
@@ -24,7 +51,11 @@ Example call:
 `
     )
     .action(async (contentTypeIds: string[], opts) => {
-      await cliCommand(['import', 'contenttypes'], opts).ImportContentTypes(
+      await cliCommand(
+        ['import', 'contenttypes'],
+        opts,
+        mapContensisOpts({ contentTypeIds, ...opts })
+      ).ImportContentTypes(
         {
           fromFile: opts.fromFile,
           commit: opts.commit,
@@ -35,10 +66,12 @@ Example call:
 
   program
     .command('components')
+    .description('import components')
     .argument(
-      '[componentIds]',
+      '[componentIds...]',
       'Optional list of API id(s) of the component(s) to import'
     )
+    .addOption(commit)
     .addHelpText(
       'after',
       `
@@ -48,7 +81,11 @@ Example call:
 `
     )
     .action(async (componentIds: string[], opts) => {
-      await cliCommand(['import', 'component'], opts).ImportComponents(
+      await cliCommand(
+        ['import', 'component'],
+        opts,
+        mapContensisOpts({ componentIds, ...opts })
+      ).ImportComponents(
         {
           fromFile: opts.fromFile,
           commit: opts.commit,
@@ -59,15 +96,24 @@ Example call:
 
   program
     .command('entries')
+    .description('import entries')
     .argument(
       '[search phrase]',
       'get entries with the search phrase, use quotes for multiple words'
     )
     .addOption(commit)
     .option(
-      '-preserve, --preserve-guids',
+      '-preserve --preserve-guids',
       'include this flag when you are importing entries that you have previously exported and wish to update'
     )
+    .addOption(
+      new Option(
+        '-oe --output-entries <outputEntries>',
+        'which details of the entries included in the import to output'
+      )
+        .choices(['errors', 'changes', 'all'])
+        .default('errors')
+    )
     .addHelpText(
       'after',
       `
@@ -80,7 +126,11 @@ Example call:
         ['import', 'entries'],
         opts,
         mapContensisOpts({ phrase, ...opts })
-      ).ImportEntries({ commit: opts.commit, fromFile: opts.fromFile });
+      ).ImportEntries({
+        commit: opts.commit,
+        fromFile: opts.fromFile,
+        logOutput: opts.outputEntries,
+      });
     });
 
   return program;

package/src/commands/index.ts

@@ -3,6 +3,9 @@ import { Logger } from '~/util/logger';
 import { LIB_VERSION } from '~/version';
 import { makeConnectCommand } from './connect';
 import { makeCreateCommand } from './create';
+import { makeDevCommand } from './dev';
+import { makeDiffCommand } from './diff';
+import { makeExecuteCommand } from './execute';
 import { makeGetCommand } from './get';
 import {
   addAuthenticationOptions,
@@ -29,6 +32,13 @@ const commands = () => {
           : str.trim() && Logger.help(str);
       },
     })
+    .addHelpText(
+      'after',
+      Logger.helpText`
+>> Each command has its own help - for example:
+  > login --help\n  > get --help
+`
+    )
     .exitOverride()
     .showHelpAfterError(true);
 
@@ -37,9 +47,20 @@ const commands = () => {
       program
     )
   );
+  program.addCommand(
+    addGlobalOptions(makeCreateCommand()).copyInheritedSettings(program)
+  );
+  program.addCommand(
+    addConnectOptions(
+      addAuthenticationOptions(makeDevCommand())
+    ).copyInheritedSettings(program)
+  );
+  program.addCommand(
+    addGlobalOptions(makeExecuteCommand()).copyInheritedSettings(program)
+  );
   program.addCommand(
     addGlobalOptions(
-      addImportOptions(makeCreateCommand())
+      addGetEntryOptions(addImportOptions(makeDiffCommand()))
     ).copyInheritedSettings(program)
   );
   program.addCommand(