contensis-cli 1.0.0-beta.62 → 1.0.0-beta.64

package/src/services/ContensisCliService.ts

@@ -21,7 +21,7 @@ import {
   Model,
   MigrateModelsResult,
 } from 'migratortron';
-import { Entry } from 'contensis-management-api/lib/models';
+import { Entry, Role } from 'contensis-management-api/lib/models';
 
 import { csvFormatter } from '~/util/csv.formatter';
 import { xmlFormatter } from '~/util/xml.formatter';
@@ -754,14 +754,19 @@ class ContensisCli {
 
         // print the key details to console
         console.log(
-          `  - ${key.name}${
-            key.description ? ` (${key.description})` : ''
-          } [${key.dateModified.toString().substring(0, 10)} ${key.modifiedBy}]`
+          `  - ${chalk.bold(key.name)} [${key.dateModified
+            .toString()
+            .substring(0, 10)} ${key.modifiedBy}]`
         );
-        console.log(`  - id: ${key.id}`);
-        console.log(`  - sharedSecret: ${key.sharedSecret}`);
+        if (key.description)
+          console.log(`    ${log.infoText(key.description)}`);
+        console.log(`    ${chalk.bold.grey`id`}: ${key.id}`);
+        console.log(
+          `    ${chalk.bold.grey`sharedSecret`}: ${key.sharedSecret}`
+        );
+        console.log('');
+        log.help(messages.keys.tip());
       }
-      console.log('');
 
       if (err) {
         log.error(messages.keys.failedCreate(currentEnv, name), err);
@@ -785,6 +790,224 @@ class ContensisCli {
     }
   };
 
+  PrintRoles = async () => {
+    const { currentEnv, log, messages } = this;
+    const contensis = await this.ConnectContensis();
+
+    if (contensis) {
+      // Retrieve roles list for env
+      const [rolesErr, roles] = await to(contensis.roles.GetRoles());
+
+      if (Array.isArray(roles)) {
+        log.success(messages.roles.list(currentEnv));
+        this.HandleFormattingAndOutput(roles, () => {
+          // print the roles to console
+          for (const {
+            id,
+            name,
+            description,
+            enabled,
+            assignments,
+            permissions,
+          } of roles) {
+            const color = enabled ? (s: string) => s : log.infoText;
+
+            console.log(color(`  - ${chalk.bold(name)} ${log.infoText(id)}`));
+            if (description) console.log(log.infoText(`    ${description}`));
+            if (enabled === false)
+              console.log(`      ${chalk.bold.grey('enabled')}: false`);
+            if (assignments.groups?.length)
+              console.log(
+                `      ${chalk.bold.grey('groups')}: ${assignments.groups.join(
+                  ', '
+                )}`
+              );
+            if (assignments.users?.length)
+              console.log(
+                `      ${chalk.bold.grey('users')}: ${assignments.users.join(
+                  ', '
+                )}`
+              );
+            if (assignments.apiKeys?.length)
+              console.log(
+                `      ${chalk.bold.grey('keys')}: ${assignments.apiKeys.join(
+                  ', '
+                )}`
+              );
+
+            if (permissions.entries?.length) {
+              console.log(`      ${chalk.bold.grey('entries')}:`);
+              for (const p of permissions.entries)
+                console.log(
+                  `        ${p.id}: ${log.infoText(
+                    p.actions.length > 2
+                      ? p.actions.length
+                      : p.actions.join(', ')
+                  )}`
+                );
+            }
+            if (permissions.contentTypes?.length)
+              console.log(
+                `      ${chalk.bold.grey(
+                  'contentTypes'
+                )}: ${permissions.contentTypes
+                  .map(
+                    p =>
+                      `${p.id} [${p.actions.join(',')}] ${p.languages.join(
+                        ' '
+                      )}`
+                  )
+                  .join(', ')}`
+              );
+          }
+        });
+      }
+
+      if (rolesErr) {
+        log.error(messages.roles.noList(currentEnv));
+        log.error(jsonFormatter(rolesErr));
+      }
+    }
+  };
+
+  PrintRole = async (roleNameOrId: string) => {
+    const { currentEnv, log, messages } = this;
+    const contensis = await this.ConnectContensis();
+
+    if (contensis) {
+      // Retrieve roles list for env
+      const [rolesErr, roles] = await to(contensis.roles.GetRoles());
+
+      if (Array.isArray(roles)) {
+        log.success(messages.roles.list(currentEnv));
+
+        const role =
+          roles.find(
+            r =>
+              r.id === roleNameOrId ||
+              r.name.toLowerCase() === roleNameOrId.toLowerCase()
+          ) ||
+          roles.find(r =>
+            r.name.toLowerCase().includes(roleNameOrId.toLowerCase())
+          );
+
+        if (role) this.HandleFormattingAndOutput(role, log.object);
+        else log.error(messages.roles.failedGet(currentEnv, roleNameOrId));
+      }
+
+      if (rolesErr) {
+        log.error(messages.roles.noList(currentEnv));
+        log.error(jsonFormatter(rolesErr));
+      }
+    }
+  };
+
+  CreateRole = async (role: Partial<Role>) => {
+    const { currentEnv, log, messages } = this;
+    const contensis = await this.ConnectContensis();
+
+    if (contensis) {
+      const [err, created] = await contensis.roles.CreateRole(role as Role);
+
+      if (created) {
+        log.success(
+          messages.roles.created(currentEnv, role.id || role.name || '')
+        );
+
+        this.HandleFormattingAndOutput(created, log.object);
+
+        log.help(messages.roles.tip());
+        return role.id;
+      }
+
+      if (err) {
+        log.error(
+          messages.roles.failedCreate(currentEnv, role.id || role.name || ''),
+          err
+        );
+      }
+    }
+  };
+
+  UpdateRole = async (roleNameOrId: string, role: Partial<Role>) => {
+    const { currentEnv, log, messages } = this;
+    const contensis = await this.ConnectContensis();
+
+    if (contensis) {
+      // Retrieve roles list for env
+      const [rolesErr, roles] = await to(contensis.roles.GetRoles());
+
+      if (Array.isArray(roles)) {
+        log.success(messages.roles.list(currentEnv));
+
+        const existingRole = roles.find(
+          r =>
+            r.id === roleNameOrId ||
+            r.name.toLowerCase() === roleNameOrId.toLowerCase()
+        );
+        if (existingRole) {
+          log.info(messages.roles.setPayload());
+          log.object(role);
+          log.raw(``);
+          const [updateErr, updated] = await contensis.roles.UpdateRole(
+            existingRole.id,
+            role
+          );
+          if (updateErr)
+            log.error(messages.roles.failedSet(currentEnv, roleNameOrId));
+          else {
+            log.success(messages.roles.set());
+
+            this.HandleFormattingAndOutput(updated, log.object);
+          }
+        } else {
+          // Role does not exist
+          log.error(messages.roles.failedGet(currentEnv, roleNameOrId));
+        }
+      }
+
+      if (rolesErr) {
+        log.error(messages.roles.noList(currentEnv));
+        log.error(jsonFormatter(rolesErr));
+      }
+    }
+  };
+
+  RemoveRole = async (roleNameOrId: string) => {
+    const { currentEnv, log, messages } = this;
+    const contensis = await this.ConnectContensis();
+
+    if (contensis) {
+      // Retrieve roles list for env
+      const [rolesErr, roles] = await to(contensis.roles.GetRoles());
+
+      if (Array.isArray(roles)) {
+        log.success(messages.roles.list(currentEnv));
+
+        const existingRole = roles.find(
+          r =>
+            r.id === roleNameOrId ||
+            r.name.toLowerCase() === roleNameOrId.toLowerCase()
+        );
+        if (existingRole) {
+          const [deleteErr] = await contensis.roles.RemoveRole(existingRole.id);
+
+          if (deleteErr)
+            log.error(messages.roles.failedRemove(currentEnv, roleNameOrId));
+          else log.success(messages.roles.removed(currentEnv, roleNameOrId));
+        } else {
+          // Role does not exist
+          log.error(messages.roles.failedGet(currentEnv, roleNameOrId));
+        }
+      }
+
+      if (rolesErr) {
+        log.error(messages.roles.noList(currentEnv));
+        log.error(jsonFormatter(rolesErr));
+      }
+    }
+  };
+
   CreateProject = async (project: Project) => {
     const { currentEnv, log, messages } = this;
     const contensis = await this.ConnectContensis();

package/src/shell.ts

@@ -135,7 +135,9 @@ class ContensisShell {
       availableCommands.push('login', 'list projects', 'set project');
     if (userId)
       availableCommands.push(
+        'create key',
         'create project',
+        'create role',
         'diff models',
         'get block',
         'get block logs',
@@ -144,6 +146,7 @@ class ContensisShell {
         'get entries',
         'get model',
         'get project',
+        'get role',
         'get version',
         'import contenttypes',
         'import components',
@@ -152,18 +155,24 @@ class ContensisShell {
         'list blocks',
         'list contenttypes',
         'list components',
-        'list models',
         'list keys',
+        'list models',
+        'list roles',
         'list webhooks',
-        'create key',
         'push block',
         'release block',
+        'remove components',
+        'remove contenttypes',
         'remove key',
         'remove entries',
-        'remove contenttypes',
-        'remove components',
+        'remove role',
         'set project name',
-        'set project description'
+        'set project description',
+        'set role name',
+        'set role description',
+        'set role assignments',
+        'set role enabled',
+        'set role permissions'
       );
 
     const prompt = inquirer.createPromptModule();

package/src/util/index.ts

@@ -27,6 +27,9 @@ export const tryStringify = (obj: any) => {
   }
 };
 
+export const isSysError = (error: any): error is Error =>
+  error?.message !== undefined && error.stack;
+
 export const isUuid = (str: string) => {
   // Regular expression to check if string is a valid UUID
   const regexExp =

package/src/util/logger.ts

@@ -2,8 +2,8 @@
 import chalk from 'chalk';
 import dateFormat from 'dateformat';
 import deepCleaner from 'deep-cleaner';
-import ProgressBar from 'progress';
-import { tryStringify } from '.';
+// import ProgressBar from 'progress';
+import { isSysError, tryStringify } from '.';
 
 type LogMethod = (content: string) => void;
 type LogErrorMethod = (content: string, err?: any, newline?: string) => void;
@@ -40,7 +40,11 @@ export class Logger {
   static error: LogErrorMethod = (content, err, newline = '\n') => {
     const message = `${Logger.getPrefix()} ${Logger.errorText(
       `${Logger.isUserTerminal ? '❌' : '[ERROR]'} ${content}${
-        err ? `\n\n${JSON.stringify(err, null, 2)}` : ''
+        err
+          ? `\n\n${
+              isSysError(err) ? err.toString() : JSON.stringify(err, null, 2)
+            }`
+          : ''
       }`
     )}${newline}`;
     if (progress.active) progress.current.interrupt(message);
@@ -92,7 +96,7 @@ export class Logger {
     Logger.raw(`  ${Logger.infoText(`-------------------------------------`)}`);
 
   static object: LogJsonMethod = content => {
-    for (const [key, value] of Object.entries(content)) {
+    for (const [key, value] of Object.entries(content || {})) {
       if (value && typeof value === 'object') {
         Logger.raw(`  ${chalk.bold.grey(key)}:`);
         if (key === 'fields' && Array.isArray(value)) {
@@ -178,14 +182,20 @@ export class Logger {
           else Logger.objectRecurse(item, depth + 1, `${indent}  `);
         } else Logger.raw(`${indent}${item}`);
       }
-    } else
+    } else {
+      let pos = 0;
       for (const [key, value] of Object.entries(content)) {
         if (Array.isArray(value)) {
+          const thisIndent =
+            pos++ === 0
+              ? `${indent.substring(0, indent.length - 2)}- `
+              : indent;
+          if (value.length) Logger.raw(`${thisIndent}${chalk.bold.grey(key)}:`);
           for (const item of value) {
             if (item && typeof item === 'object') {
               if (Array.isArray(item) && depth > 3)
                 Logger.raw(chalk.grey(`${indent}  [${item.join(', ')}]`));
-              else Logger.objectRecurse(item, depth + 1, `${indent}`);
+              else Logger.objectRecurse(item, depth + 1, `${indent}  `);
             } else {
               Logger.raw(`${indent}  ${item}`);
             }
@@ -199,6 +209,7 @@ export class Logger {
           Logger.raw(`${indent}${chalk.bold.grey(key)}: ${value}`);
         }
       }
+    }
   };
   static raw: LogMethod = (content: string) => {
     if (progress.active) progress.current.interrupt(content);
@@ -222,13 +233,14 @@ export const logError: LogErrorFunc = (
 };
 
 export const progress = {
+  current: { interrupt: (x: string) => {} },
   active: false,
-  done: () => new ProgressBar('', 0),
-  colours: { green: '\u001b[42m \u001b[0m', red: '\u001b[41m \u001b[0m' },
-  current: new ProgressBar(`:bar`, {
-    complete: '=',
-    incomplete: ' ',
-    width: 20,
-    total: 100,
-  }),
+  // done: () => new ProgressBar('', 0),
+  // colours: { green: '\u001b[42m \u001b[0m', red: '\u001b[41m \u001b[0m' },
+  // current: new ProgressBar(`:bar`, {
+  //   complete: '=',
+  //   incomplete: ' ',
+  //   width: 20,
+  //   total: 100,
+  // }),
 };

package/src/version.ts

@@ -1 +1 @@
-export const LIB_VERSION = "1.0.0-beta.62";
+export const LIB_VERSION = "1.0.0-beta.64";