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

package/src/commands/list.ts

@@ -1,20 +1,17 @@
 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')
+    .description('list command')
+    .addHelpText('after', `\n`)
     .showHelpAfterError(true)
     .exitOverride();
 
   list
     .command('envs')
+    .description('List all previously connected environments')
     .addHelpText(
       'after',
       `
@@ -25,11 +22,38 @@ Example call:
     .action(opts => {
       cliCommand(['list', 'envs'], opts).PrintEnvironments();
     });
-  list.command('projects').action(async opts => {
-    await cliCommand(['list', 'projects'], opts).PrintProjects();
-  });
+
+  list
+    .command('projects')
+    .description('print list of projects')
+    .addHelpText(
+      'after',
+      `
+Example call:
+  > list projects
+`
+    )
+    .action(async opts => {
+      await cliCommand(['list', 'projects'], opts).PrintProjects();
+    });
+
+  list
+    .command('models')
+    .description('print list of content models')
+    .addHelpText(
+      'after',
+      `
+Example call:
+  > list models
+`
+    )
+    .action(async opts => {
+      await cliCommand(['list', 'models'], opts).PrintContentModels();
+    });
+
   list
     .command('contenttypes')
+    .description('print list of content types')
     .addHelpText(
       'after',
       `
@@ -40,8 +64,10 @@ Example call:
     .action(async opts => {
       await cliCommand(['list', 'contenttypes'], opts).PrintContentTypes();
     });
+
   list
     .command('components')
+    .description('print list of components')
     .addHelpText(
       'after',
       `
@@ -52,8 +78,10 @@ Example call:
     .action(async opts => {
       await cliCommand(['list', 'components'], opts).PrintComponents();
     });
+
   list
     .command('blocks')
+    .description('print list of content blocks')
     .addHelpText(
       'after',
       `
@@ -64,8 +92,10 @@ Example call:
     .action(async opts => {
       await cliCommand(['list', 'blocks'], opts).PrintBlocks();
     });
+
   list
     .command('keys')
+    .description('print list of API keys')
     .addHelpText(
       'after',
       `
@@ -76,14 +106,58 @@ Example call:
     .action(async opts => {
       await cliCommand(['list', 'keys'], opts).PrintApiKeys();
     });
+
+  list
+    .command('proxies')
+    .description('print list of proxies')
+    .addHelpText(
+      'after',
+      `
+Example call:
+  > list proxies
+`
+    )
+    .action(async opts => {
+      await cliCommand(['list', 'proxies'], opts).PrintProxies();
+    });
+
+  list
+    .command('renderers')
+    .description('print list of renderers')
+    .addHelpText(
+      'after',
+      `
+Example call:
+  > list renderers
+`
+    )
+    .action(async opts => {
+      await cliCommand(['list', 'renderers'], opts).PrintRenderers();
+    });
+
+  list
+    .command('roles')
+    .description('print list of roles')
+    .addHelpText(
+      'after',
+      `
+Example call:
+  > list roles
+`
+    )
+    .action(async opts => {
+      await cliCommand(['list', 'roles'], opts).PrintRoles();
+    });
+
   list
     .command('webhooks')
+    .description('print list of webhooks')
     .argument('[name]', 'find webhooks matching the supplied name')
     .option('-i --id <id...>', 'the subscription id(s) to get')
+    .addHelpText('after', `\n`)
     .action(async (name?: string, { id, ...opts }: any = {}) => {
       await cliCommand(['list', 'webhooks'], opts).PrintWebhookSubscriptions(
-        id,
-        name
+        name ? [name] : id
       );
     });
   return list;

package/src/commands/login.ts

@@ -5,6 +5,7 @@ import { shell } from '~/shell';
 export const makeLoginCommand = () => {
   const login = new Command()
     .command('login')
+    .description('login to a connected Contensis instance')
     .argument('<user/clientId>', 'the username to login with')
     .argument(
       '[password]',
@@ -27,7 +28,7 @@ Example call:
         password,
         sharedSecret: opts.sharedSecret,
       });
-      if (token) await shell().start();
+      if (token) await shell().restart();
     });
   return login;
 };

package/src/commands/push.ts

@@ -6,11 +6,14 @@ import { cliCommand } from '~/services/ContensisCliService';
 export const makePushCommand = () => {
   const push = new Command()
     .command('push')
+    .description('push command')
+    .addHelpText('after', `\n`)
     .showHelpAfterError(true)
     .exitOverride();
 
   push
     .command('block')
+    .description('push a block')
     .argument('<block-id>', 'the name of the block to push to')
     .argument(
       '<image uri:tag>',
@@ -18,36 +21,36 @@ export const makePushCommand = () => {
     )
     .argument('[branch]', 'the branch we are pushing to')
     .option(
-      '-r, --release',
+      '-r --release',
       'whether to release the pushed block version',
       false
     )
     .option(
-      '-cid, --commit-id <commitId>',
+      '-cid --commit-id <commitId>',
       'the id of the source git commit for the supplied image uri'
     )
     .option(
-      '-cmsg, --commit-message <commitMessage>',
+      '-cmsg --commit-message <commitMessage>',
       'the git commit message for the supplied commit id'
     )
     .option(
-      '-cdt, --commit-datetime <commitDateTime>',
+      '-cdt --commit-datetime <commitDateTime>',
       'the timestamp of the source git commit for the supplied image uri'
     )
     .option(
-      '-author, --author-email <authorEmail>',
+      '-author --author-email <authorEmail>',
       'the git email address of the author of the source git commit'
     )
     .option(
-      '-committer, --committer-email <committerEmail>',
+      '-committer --committer-email <committerEmail>',
       'the git email address of the commiter of the source git commit'
     )
     .option(
-      '-repo, --repository-url <repositoryUrl>',
+      '-repo --repository-url <repositoryUrl>',
       'the url of the source repository for the supplied image uri'
     )
     .option(
-      '-pr, --provider <sourceProvider>',
+      '-pr --provider <sourceProvider>',
       'the url of the source repository for the supplied image uri'
     )
     .usage('<block-id> <image uri> [branch] [options]')
@@ -55,7 +58,7 @@ export const makePushCommand = () => {
       'after',
       `
 Example call:
-  > push block contensis-app ghcr.io/contensis/contensis-app/build-4359 master --release\n`
+  > push block contensis-app ghcr.io/contensis/contensis-app/app:build-4359 master --release\n`
     )
     .action(async (blockId: string, imageUri: string, branch: string, opts) => {
       const cli = cliCommand(['push', 'block', blockId], opts);
@@ -68,7 +71,7 @@ Example call:
       };
 
       const blockRequest = mapJson(mapSourceVars, {
-        autoRelease: { $path: 'release', $default: () => false },
+        release: { $path: 'release', $default: () => false },
         id: ['blockId'],
         image: () => {
           const lastIndexOfColon = imageUri.lastIndexOf(':');
@@ -99,7 +102,11 @@ Example call:
           branch: ['branch', 'CI_COMMIT_REF_NAME', 'GITHUB_REF_NAME'],
           commit: {
             id: ['commitId', 'CI_COMMIT_SHORT_SHA', 'GITHUB_SHA'],
-            message: ['commitMessage', 'CI_COMMIT_MESSAGE'], // ${{ github.event.head_commit.message }}
+            message: {
+              $path: ['commitMessage', 'CI_COMMIT_MESSAGE'], // ${{ github.event.head_commit.message }}
+              $formatting: (msg?: string) =>
+                msg?.replace(/\\n/g, ' ').replace(/\\n/g, ' ').trim(),
+            },
             dateTime: ['commitDatetime', 'CI_COMMIT_TIMESTAMP'], // ${{ github.event.head_commit.timestamp }}
             authorEmail: ['authorEmail', 'GITLAB_USER_EMAIL', 'GITHUB_ACTOR'], // ${{ github.event.head_commit.author.email }}
             committerEmail: [

package/src/commands/remove.ts

@@ -1,27 +1,34 @@
 import { Command } from 'commander';
 import { cliCommand } from '~/services/ContensisCliService';
 import { shell } from '~/shell';
-import { commit, mapContensisOpts } from './globalOptions';
+import { Logger } from '~/util/logger';
+import { commit, mapContensisOpts, zenql } from './globalOptions';
 
 export const makeRemoveCommand = () => {
   const remove = new Command()
     .command('remove')
+    .description('remove command')
+    .addHelpText('after', `\n`)
     .showHelpAfterError(true)
     .exitOverride();
 
   remove
     .command('project')
+    .description('remove an entire project')
     .argument('<projectId>', 'the project id to delete')
     .usage('<projectId>')
+    .addHelpText('after', `\n`)
     .action(async (projectId, opts) => {
       const project = await cliCommand(
         ['remove', 'project', projectId],
         opts
       ).SetProject(projectId);
-      if (project) await shell().start();
+      if (project) await shell().restart();
     });
+
   remove
     .command('key')
+    .description('remove api key')
     .argument('<id>', 'the id of the API key to delete')
     .usage('<id>')
     .addHelpText(
@@ -35,8 +42,25 @@ Example call:
       await cliCommand(['remove', 'key', id], opts).RemoveApiKey(id);
     });
 
+  remove
+    .command('role')
+    .description('remove a role')
+    .argument('<"Role name" or id>', 'the existing role name or id to delete')
+    .addHelpText(
+      'after',
+      `
+Example call:
+  > remove role "My role"\n`
+    )
+    .action(async (roleNameOrId: string, opts) => {
+      await cliCommand(['remove', 'role', roleNameOrId], opts).RemoveRole(
+        roleNameOrId
+      );
+    });
+
   remove
     .command('components')
+    .description('delete components')
     .argument('<id...>', 'the id(s) of the components to delete')
     .addOption(commit)
     .usage('<id> [--commit]')
@@ -49,13 +73,14 @@ Example call:
     )
     .action(async (id: string[], opts) => {
       await cliCommand(
-        ['remove', 'components', id.join(', ')],
+        ['remove', 'components', id.join(' ')],
         opts
       ).RemoveComponents(id, opts.commit);
     });
 
   remove
     .command('contenttypes')
+    .description('delete content types')
     .argument('<id...>', 'the id(s) of the content types to delete')
     .addOption(commit)
     .usage('<id> [--commit]')
@@ -68,10 +93,47 @@ Example call:
     )
     .action(async (id: string[], opts) => {
       await cliCommand(
-        ['remove', 'contenttypes', id.join(', ')],
+        ['remove', 'contenttypes', id.join(' ')],
         opts
       ).RemoveContentTypes(id, opts.commit);
     });
 
+  const removeEntries = remove
+    .command('entries')
+    .description('delete entries')
+    .argument(
+      '[ids...]',
+      'the entry id(s) to delete ...or add *** if you wish to delete all entries in all content types'
+    )
+    .addOption(zenql)
+    .addOption(commit)
+    .addHelpText(
+      'after',
+      `
+Example call:
+  > remove entries a1c25591-8c9b-50e2-96d8-f6c774fcf023 8df914cc-1da1-59d6-86e0-8ea4ebd99aaa
+  > remove entries --zenql "sys.contentTypeId = test"
+`
+    )
+    .action(async (entryIds: string[], opts) => {
+      const removeAll = entryIds?.[0] === '***';
+
+      // Remove all asterisks from args
+      if (entryIds?.[0] && !entryIds[0].replace(/\*/g, '')) entryIds.pop();
+
+      const hasArgs = !!(entryIds?.length || opts.zenql || removeAll);
+      if (!hasArgs) {
+        Logger.help(
+          `Not enough arguments supplied\n\n${removeEntries.helpInformation()}`
+        );
+      } else {
+        await cliCommand(
+          ['remove', 'entries', entryIds.join(' ')],
+          opts,
+          mapContensisOpts({ entryIds, ...opts })
+        ).RemoveEntries(opts.commit);
+      }
+    });
+
   return remove;
 };

package/src/commands/set.ts

@@ -5,35 +5,215 @@ import { shell } from '~/shell';
 export const makeSetCommand = () => {
   const set = new Command()
     .command('set')
+    .description('set command')
+    .addHelpText('after', `\n`)
     .showHelpAfterError(true)
     .exitOverride();
-  set
+
+  const project = set
     .command('project')
+    .description('set current working project')
     .argument('<projectId>', 'the project id to work with')
     .usage('<projectId>')
+    .addHelpText(
+      'after',
+      `
+Example call:
+  > set project website\n`
+    )
     .action(async projectId => {
-      const project = await cliCommand([
+      const nextProjectId = cliCommand([
         'set',
         'project',
         projectId,
       ]).SetProject(projectId);
-      if (project) await shell().start();
+      if (nextProjectId) await shell().restart();
+    });
+
+  project
+    .command('name')
+    .description('update project name')
+    .argument('<"Project name">', 'update the current project name')
+    .usage('<"Project name">')
+    .addHelpText(
+      'after',
+      `
+Example call:
+  > set project name "Project name"\n`
+    )
+    .action(async (name: string, opts) => {
+      await cliCommand(['set', 'project', 'name'], opts).UpdateProject({
+        name,
+      });
+    });
+
+  project
+    .command('description')
+    .description('update project description')
+    .argument(
+      '<"Project description">',
+      'update the current project description'
+    )
+    .usage('<"Project description">')
+    .addHelpText(
+      'after',
+      `
+Example call:
+  > set project description "Description of project"\n`
+    )
+    .action(async (description: string, opts) => {
+      await cliCommand(['set', 'project', 'description'], opts).UpdateProject({
+        description,
+      });
+    });
+
+  const role = set.command('role').description('update a role');
+
+  role
+    .command('name')
+    .description('update role name')
+    .argument('<"Role name">', 'update the existing role name')
+    .argument('<"New name">', 'the new name for the role')
+    .usage('<"Role name"> <"New name">')
+    .addHelpText(
+      'after',
+      `
+Example call:
+  > set role name "Existing name" "New role name"\n`
+    )
+    .action(async (roleNameOrId: string, newName: string, opts) => {
+      await cliCommand(['set', 'role', 'name'], opts).UpdateRole(roleNameOrId, {
+        name: newName,
+      });
+    });
+
+  role
+    .command('description')
+    .description('update role description')
+    .argument('<"Role name" or id>', 'the existing role name or id to update')
+    .argument('<"New description">', 'the new description for the role')
+    .usage('<"Role name"> <"New description">')
+    .addHelpText(
+      'after',
+      `
+Example call:
+  > set role description "Existing role" "New role description"\n`
+    )
+    .action(async (roleNameOrId: string, description: string, opts) => {
+      await cliCommand(['set', 'role', 'description'], opts).UpdateRole(
+        roleNameOrId,
+        {
+          description,
+        }
+      );
     });
+
+  role
+    .command('enabled')
+    .description('enable or disable a role')
+    .argument('<"Role name" or id>', 'the existing role name or id to update')
+    .usage('<"Role name"> --disabled')
+    .option('--disabled', 'disable the role', false)
+    .addHelpText(
+      'after',
+      `
+Example call:
+  > set role enabled "Existing role"\n
+  > set role enabled "Other role" --disabled\n`
+    )
+    .action(async (roleNameOrId: string, opts) => {
+      await cliCommand(
+        ['set', 'role', opts.disabled ? 'disabled' : 'enabled'],
+        opts
+      ).UpdateRole(roleNameOrId, {
+        enabled: !opts.disabled,
+      });
+    });
+
+  role
+    .command('assignments')
+    .description('assign users, groups or keys to a role')
+    .argument('<"Role name" or id>', 'the role name or id to update')
+    .option(
+      '-users --assign-users [assign-users...]',
+      'the user id(s) to assign'
+    )
+    .option(
+      '-groups --assign-groups [assign-groups...]',
+      'the groups name(s) to assign'
+    )
+    .option('-keys --assign-keys [assign-keys...]', 'the key name(s) to assign')
+    .addHelpText(
+      'after',
+      `
+Example call:
+  > set role assignments "My role" --assign-users admin \n`
+    )
+    .action(async (roleNameOrId: string, opts) => {
+      await cliCommand(['set', 'role', 'assignments'], opts).UpdateRole(
+        roleNameOrId,
+        {
+          assignments: {
+            apiKeys: opts.assignKeys || undefined,
+            groups: opts.assignGroups || undefined,
+            users: opts.assignUsers || undefined,
+          },
+        }
+      );
+    });
+
+  role
+    .command('permissions')
+    .description('add entry permissions to a role')
+    .argument('<"Role name" or id>', 'the role name or id to update')
+    .option(
+      '-contenttypes --content-type-ids [content-type-id...]',
+      'any content type ids to add permissions for'
+    )
+    .option(
+      '--entry-actions [entry-actions...]',
+      'the entry actions to add to the role permissions'
+    )
+    .option(
+      '--entry-languages [entry-languages...]',
+      'the entry languages to add to the role permissions'
+    )
+    .addHelpText(
+      'after',
+      `
+Example call:
+  > set role permissions "My role" --content-type-id blogs -- \n`
+    )
+    .action(async (roleNameOrId: string, opts) => {
+      await cliCommand(['set', 'role', 'permissions'], opts).UpdateRole(
+        roleNameOrId,
+        {
+          permissions: {
+            entries: opts.contentTypeIds?.map((id: string) => ({
+              id,
+              actions: opts.entryActions || [],
+              languages: opts.entryLanguages || [],
+            })),
+          },
+        }
+      );
+    });
+
   set
     .command('version')
+    .description('set content version')
     .addArgument(
       new Argument('<versionStatus>', 'content version status')
         .choices(['latest', 'published'])
         .default('latest')
     )
     .usage('<latest/published>')
+    .addHelpText('after', `\n`)
     .action(async versionStatus => {
-      const success = await cliCommand([
-        'set',
-        'version',
-        versionStatus,
-      ]).SetVersion(versionStatus);
-      if (success) await shell().start();
+      const success = cliCommand(['set', 'version', versionStatus]).SetVersion(
+        versionStatus
+      );
+      if (success) await shell().restart();
     });
 
   return set;

package/src/index.ts

@@ -1,8 +1,6 @@
 import commands from './commands';
 import { logError } from './util/logger';
 import ContensisCli from './services/ContensisCliService';
-import { jsonFormatter } from './util/json.formatter';
-// new ContensisCli(process.argv).DoCommandTasksAsync();
 
 // This is the CLI part of the app
 const program = commands();
@@ -12,8 +10,7 @@ program
     ContensisCli.quit();
   })
   .catch((err: any) => {
-    if (!err.name?.includes('CommanderError'))
+    if (err && !err.name?.includes('CommanderError'))
       logError(err, `CLI ${err.toString()}`);
     ContensisCli.quit(err);
   });
-//.exitOverride(() => console.log('exit override!!!'));