contensis-cli 1.0.0-beta.5

package/src/shell.ts

@@ -0,0 +1,250 @@
+import path from 'path';
+import figlet from 'figlet';
+import inquirer from 'inquirer';
+import inquirerPrompt from 'inquirer-command-prompt';
+import commands from './commands';
+import { LogMessages } from './localisation/en-GB';
+import { logError, Logger } from './util/logger';
+import CredentialProvider from './providers/CredentialProvider';
+import ContensisCli, { cliCommand } from './services/ContensisCliService';
+import { Logging } from './util';
+
+class ContensisShell {
+  private currentEnvironment!: string;
+  private emptyInputCounter: number = 0;
+  private env!: EnvironmentCache;
+  private firstStart = true;
+  private userId: string = '';
+  private log = Logger;
+  private messages = LogMessages;
+
+  private refreshEnvironment = () => {
+    // Reload any persisted changes from the disk cache
+    const {
+      cache: { currentEnvironment = '', environments = {} },
+    } = new ContensisCli([]);
+    // console.log(`refreshing env w/${currentEnvironment}`);
+    this.currentEnvironment = currentEnvironment;
+    this.env = environments[currentEnvironment];
+
+    // Reload logging here to support changing language
+    Logging('en-GB').then(({ messages, Log }) => {
+      this.log = Log;
+      this.messages = messages;
+    });
+  };
+
+  constructor() {
+    this.refreshEnvironment();
+    inquirerPrompt.setConfig({
+      history: {
+        save: true,
+        folder: path.join(__dirname, '../'),
+        limit: 100,
+        blacklist: ['quit'],
+      },
+    });
+    // inquirer.registerPrompt('command', inquirerPrompt);
+
+    const { log, messages } = this;
+
+    figlet.text(
+      messages.app.contensis(),
+      {
+        font: 'Block',
+        horizontalLayout: 'default',
+        verticalLayout: 'default',
+        width: process.stdout.columns,
+        whitespaceBreak: true,
+      },
+      (err, data) => {
+        if (err) {
+          log.error(messages.app.unknownError());
+          console.dir(err);
+          return;
+        }
+        console.log(log.successText(data));
+        console.log(log.infoText(messages.app.startup()));
+        console.log(log.helpText(messages.app.help()));
+
+        this.start().catch(ex => log.error(ex));
+      }
+    );
+  }
+
+  start = async () => {
+    this.log.line();
+    this.refreshEnvironment();
+    this.userId = '';
+    const { currentEnvironment, env, log, messages } = this;
+
+    if (env?.lastUserId) {
+      const [credsErr, credentials] = await new CredentialProvider(
+        {
+          userId: env.lastUserId,
+          alias: currentEnvironment,
+        },
+        env.passwordFallback
+      ).Init();
+      if (credsErr && !credentials.current) {
+        log.error(credsErr.message);
+      }
+      if (credentials.current) {
+        if (this.firstStart) {
+          const token = await cliCommand(['login', env.lastUserId]).Login(
+            env.lastUserId,
+            {
+              promptPassword: false,
+              silent: true,
+            }
+          );
+          if (token) this.userId = env.lastUserId;
+          this.firstStart = false;
+          this.refreshEnvironment();
+        } else {
+          this.userId = env.lastUserId;
+        }
+      }
+    }
+    await this.contensisPrompt();
+  };
+
+  contensisPrompt = async (): Promise<any> => {
+    const { currentEnvironment, env, log, messages, userId } = this;
+
+    const availableCommands = [
+      {
+        filter: (str: string) => {
+          return str.replace(/ \[.*$/, '');
+        },
+      },
+      'connect',
+      'list envs',
+      'quit',
+    ];
+
+    if (currentEnvironment)
+      availableCommands.push('login', 'list projects', 'set project');
+    if (userId)
+      availableCommands.push(
+        'get block',
+        'get block logs',
+        'get contenttype',
+        'get component',
+        'get entries',
+        'import contenttypes',
+        'import components',
+        'import entries',
+        'list blocks',
+        'list contenttypes',
+        'list components',
+        'list models',
+        'list keys',
+        'list webhooks',
+        'create key',
+        'push block',
+        'remove key',
+        'remove entry',
+        'remove contenttypes',
+        'remove components'
+      );
+
+    const prompt = inquirer.createPromptModule();
+    prompt.registerPrompt('command', inquirerPrompt);
+    return prompt([
+      {
+        type: 'command',
+        name: 'cmd',
+        autoCompletion: availableCommands,
+        autocompletePrompt: log.infoText(messages.app.autocomplete()),
+        message: `${userId ? `${userId}@` : ''}${currentEnvironment || ''}>`,
+        context: 0,
+        validate: (val: string) => {
+          if (!val) this.emptyInputCounter++;
+          if (this.emptyInputCounter > 1)
+            console.log(this.log.infoText(this.messages.app.suggestions()));
+          if (val) {
+            this.emptyInputCounter = 0;
+            return true;
+          }
+        },
+        prefix: `${env?.currentProject || 'contensis'}`,
+        short: true,
+      },
+    ])
+      .then(async (answers: { cmd: string }) => {
+        if (answers.cmd === 'quit') {
+          this.quit();
+        } else {
+          try {
+            if (answers.cmd) {
+              const program = commands();
+              await program.parseAsync(
+                answers.cmd
+                  .match(/"[^"]+"|[^\s]+/g)
+                  ?.map(e => e.replace(/"(.+)"/, '$1')),
+                {
+                  from: 'user',
+                }
+              );
+            }
+          } catch (ex: any) {
+            const str = ex.toString();
+            if (!str.includes('CommanderError'))
+              logError(ex, `Shell ${ex.toString()}`);
+          } finally {
+            return this.contensisPrompt();
+          }
+        }
+      })
+      .catch((err: Error) => {
+        log.error(err.message);
+        this.quit();
+      });
+  };
+
+  quit = (error?: Error) => {
+    const { log, messages } = this;
+    process.removeAllListeners('exit');
+
+    if (error) {
+      log.error(error.message);
+      process.exit(1);
+    } else {
+      log.success(messages.app.quit());
+      process.exitCode = 0;
+      process.exit(0);
+    }
+  };
+}
+
+let globalShell: ContensisShell;
+
+export const shell = () => {
+  if (typeof process.argv?.[2] !== 'undefined') return { start() {} } as any;
+  if (!globalShell) globalShell = new ContensisShell();
+  return globalShell;
+};
+
+process.on('uncaughtException', function (err) {
+  // Handle the error safely
+  console.log(err);
+});
+
+process.on('SIGINT', () => {
+  console.log('catching SIGINT');
+  shell().quit();
+});
+
+process.on('SIGTERM', () => {
+  console.log('catching SIGTERM');
+  shell().quit();
+});
+
+process.stdin.on('data', key => {
+  if ((key as any) == '\u0003') {
+    console.log('');
+    Logger.info(`[CTRL]+[C] detected, exiting shell...`);
+    shell().quit();
+  }
+});

package/src/util/console.printer.ts

@@ -0,0 +1,203 @@
+import dayjs from 'dayjs';
+import { BlockVersion, MigrateStatus } from 'migratortron';
+import ContensisCli from '~/services/ContensisCliService';
+
+const formatDate = (date: Date | string, format = 'DD/MM/YYYY HH:mm') =>
+  dayjs(date).format(format);
+
+export const printBlockVersion = (
+  { log, messages }: ContensisCli,
+  block: BlockVersion,
+  printOptions = {
+    showSource: true,
+    showStatus: true,
+    showStaticPaths: true,
+    showImage: true,
+  }
+) => {
+  console.log(
+    `  ${log.standardText(`v${block.version.versionNo}`)} ${block.id}`
+  );
+  console.log(
+    `    state: ${messages.blocks.runningStatus(
+      block.status.broken ? 'broken' : block.status.running.global
+    )}`
+  );
+  console.log(
+    `    released: ${log.infoText(
+      block.version.released
+        ? `[${formatDate(block.version.released)}] ${block.version.releasedBy}`
+        : 'no'
+    )}`
+  );
+  if (block.version.madeLive)
+    console.log(
+      `    live: ${log.infoText(
+        `[${formatDate(block.version.madeLive)}] ${block.version.madeLiveBy}`
+      )}`
+    );
+  if (printOptions.showStatus) {
+    console.log(`    status:`);
+    console.log(`      deployment: ${log.infoText(block.status.deployment)}`);
+    console.log(`      workflow: ${log.infoText(block.status.workflow)}`);
+    console.log(
+      `      running status: ${messages.blocks.runningStatus(
+        block.status.running.global
+      )}`
+    );
+    console.log(`      datacentres:`);
+    console.log(
+      `        hq: ${messages.blocks.runningStatus(
+        block.status.running.dataCenters.hq
+      )}`
+    );
+    console.log(
+      `        london: ${messages.blocks.runningStatus(
+        block.status.running.dataCenters.london
+      )}`
+    );
+    console.log(
+      `        manchester: ${messages.blocks.runningStatus(
+        block.status.running.dataCenters.manchester
+      )}`
+    );
+  }
+  if (printOptions.showSource) {
+    console.log(`    source:`);
+    console.log(`      commit: ${log.helpText(block.source.commit.id)}`);
+    console.log(
+      `      message: ${log.infoText(
+        block.source.commit.message
+          ?.replaceAll('\n', '\\n')
+          .replaceAll('\\n\\n', '\\n')
+          .replaceAll('\\n', '; ')
+      )}`
+    );
+    console.log(
+      `      committed: ${log.infoText(
+        `[${formatDate(block.source.commit.dateTime)}] ${
+          block.source.commit.authorEmail
+        }`
+      )}`
+    );
+    console.log(
+      `      pushed: ${log.infoText(
+        `[${formatDate(block.version.pushed)}] ${block.version.pushedBy}`
+      )}`
+    );
+    console.log(`      ${log.infoText(block.source.commit.commitUrl)}`);
+  }
+  if (printOptions.showImage) {
+    console.log(`    image:`);
+    console.log(`      uri: ${log.infoText(block.image.uri)}`);
+    console.log(`      tag: ${log.helpText(block.image.tag)}`);
+  }
+  if (printOptions.showStaticPaths) {
+    if (block.staticPaths?.length) {
+      console.log(`    static paths:`);
+      for (const path of block.staticPaths) console.log(`      - ${path}`);
+    }
+  }
+  if (block.stagingUrl)
+    console.log(`    staging url: ${log.infoText(block.stagingUrl)}`);
+  console.log('');
+};
+
+export const printMigrateResult = (
+  { log, messages, contensis, currentProject }: ContensisCli,
+  migrateResult: any,
+  { action = 'import' }: { action?: 'import' | 'delete' } = {}
+) => {
+  console.log(``);
+
+  if (action === 'import') {
+    for (const [projectId, contentTypeCounts] of Object.entries(
+      migrateResult.entries || {}
+    ) as [string, any][]) {
+      console.log(
+        `import from project ${log.highlightText(projectId)} to ${log.boldText(
+          log.successText(currentProject)
+        )}`
+      );
+      for (const [contentTypeId, count] of Object.entries(
+        contentTypeCounts
+      ) as [string, number][]) {
+        const entriesToMigrate =
+          migrateResult.entriesToMigrate?.[projectId]?.[contentTypeId];
+
+        console.log(
+          `  - ${
+            contentTypeId === 'totalCount'
+              ? log.warningText(`${contentTypeId}: ${count}`)
+              : log.helpText(`${contentTypeId}: ${count}`)
+          } ${log.infoText`[existing: ${(
+            ((migrateResult.existing?.[projectId]?.[contentTypeId] || 0) /
+              count) *
+            100
+          ).toFixed(0)}%]`} [${
+            typeof entriesToMigrate !== 'number' ? `unchanged` : `to update`
+          }: ${(
+            ((typeof entriesToMigrate !== 'number'
+              ? entriesToMigrate?.['no change'] || 0
+              : entriesToMigrate) /
+              count) *
+            100
+          ).toFixed(0)}%]`
+        );
+      }
+      console.log(``);
+    }
+  }
+  if (
+    contensis?.isPreview &&
+    migrateResult.entriesToMigrate?.[currentProject]?.totalCount > 0 &&
+    !migrateResult.errors
+  ) {
+    log.help(messages.entries.commitTip());
+  }
+  for (const [contentTypeId, entryRes] of Object.entries(
+    migrateResult.entriesToMigrate.entryIds
+  ) as [string, any]) {
+    for (const [originalId, entryStatus] of Object.entries(entryRes) as [
+      string,
+      any
+    ][]) {
+      console.log(
+        log.infoText(
+          `${originalId} [${Object.entries(entryStatus || {})
+            .filter(x => x[0] !== 'entryTitle')
+            .map(([projectId, projectStatus]) => {
+              const [targetGuid, { status }] = (Object.entries(
+                projectStatus || {}
+              )?.[0] as [string, { status: MigrateStatus }]) || [
+                '',
+                { x: { status: undefined } },
+              ];
+              return `${messages.entries.migrateStatus(status)(
+                `${projectId}: ${status}`
+              )}${targetGuid !== originalId ? `-> ${targetGuid}` : ''}`;
+            })}]`
+        )
+      );
+      console.log(`  ${log.helpText(contentTypeId)} ${entryStatus.entryTitle}`);
+
+      for (const [projectId, projectStatus] of Object.entries(
+        entryStatus
+      ).filter(([key]) => key !== 'entryTitle') as [string, any][]) {
+        const [targetGuid, { error, diff, status }] = Object.entries(
+          projectStatus
+        )[0] as [string, any];
+        if (error) log.error(error);
+        if (diff) {
+          console.log(
+            `  ${messages.entries.migrateStatus(status)(status)} ${log.infoText(
+              targetGuid
+            )} ${log.infoText(contentTypeId)} ${log.infoText(projectId)}`
+          );
+          console.log(``);
+          console.log(log.highlightText(diff));
+        }
+      }
+    }
+  }
+};

package/src/util/csv.formatter.ts

@@ -0,0 +1,21 @@
+import { flatten } from 'flat';
+import { Parser } from 'json2csv';
+import cleaner from 'deep-cleaner';
+
+const flattenObject = (obj: any) => flatten(cleaner(obj, ['workflow']));
+
+export const csvFormatter = <T>(entries: T | T[]) => {
+  // Flatten the passed in object
+  const flatEntries = [];
+  if (Array.isArray(entries))
+    for (const entry of entries) {
+      flatEntries.push(flattenObject(entry));
+    }
+  else flatEntries.push(flattenObject(entries));
+
+  // Parse the flattened object to csv
+  const json2csvParser = new Parser();
+  const csv = json2csvParser.parse(flatEntries);
+
+  return csv;
+};

package/src/util/index.ts

@@ -0,0 +1,67 @@
+import mergeWith from 'lodash/mergeWith';
+import { Logger } from './logger';
+
+export const isSharedSecret = (str = '') =>
+  str.length > 80 && str.split('-').length === 3 ? str : undefined;
+
+export const isPassword = (str = '') =>
+  !isSharedSecret(str) ? str : undefined;
+
+export const tryParse = (str: string) => {
+  try {
+    return typeof str === 'object' ? str : JSON.parse(str);
+  } catch (e) {
+    return false;
+  }
+};
+
+export const isJson = (str: string) =>
+  typeof str === 'object' || !!tryParse(str);
+
+export const tryStringify = (obj: any) => {
+  try {
+    return typeof obj === 'object' ? JSON.stringify(obj) : obj;
+  } catch (e) {
+    return obj;
+  }
+};
+
+export const isUuid = (str: string) => {
+  // Regular expression to check if string is a valid UUID
+  const regexExp =
+    /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/gi;
+
+  return regexExp.test(str);
+};
+
+export const url = (alias: string, project: string) => {
+  const projectAndAlias =
+    project && project.toLowerCase() !== 'website'
+      ? `${project.toLowerCase()}-${alias}`
+      : alias;
+  return {
+    api: `https://api-${alias}.cloud.contensis.com`,
+    cms: `https://cms-${alias}.cloud.contensis.com`,
+    liveWeb: `https://live-${projectAndAlias}.cloud.contensis.com`,
+    previewWeb: `https://preview-${projectAndAlias}.cloud.contensis.com`,
+    iisWeb: `https://iis-live-${projectAndAlias}.cloud.contensis.com`,
+    iisPreviewWeb: `https://iis-preview-${projectAndAlias}.cloud.contensis.com`,
+  };
+};
+
+export const Logging = async (language = 'en-GB') => {
+  const { LogMessages: defaultMessages } = await import(
+    `../localisation/en-GB.js`
+  );
+  const { LogMessages: localisedMessages } = await import(
+    `../localisation/${language}.js`
+  );
+  return {
+    messages: mergeWith(
+      localisedMessages,
+      defaultMessages,
+      (v, s) => v || s
+    ) as typeof defaultMessages,
+    Log: Logger,
+  };
+};

package/src/util/json.formatter.ts

@@ -0,0 +1 @@
+export const jsonFormatter = <T>(obj: T) => JSON.stringify(obj, null, 2);

package/src/util/logger.ts

@@ -0,0 +1,165 @@
+/* eslint-disable no-console */
+import chalk from 'chalk';
+import dateFormat from 'dateformat';
+import deepCleaner from 'deep-cleaner';
+import ProgressBar from 'progress';
+import { tryStringify } from '.';
+
+type LogMethod = (content: string) => void;
+type LogErrorMethod = (content: string, err?: any) => void;
+type LogJsonMethod = (content: any) => void;
+type LogArrayMethod = (contentArray: string[]) => void;
+type LogErrorFunc = (
+  err: any,
+  msg?: string,
+  level?: 'error' | 'critical'
+) => void;
+
+export class Logger {
+  static isUserTerminal = !!process.stdout.columns;
+  static getPrefix = () => {
+    return Logger.isUserTerminal
+      ? Logger.infoText(`[cli]`)
+      : `[${dateFormat(new Date(), 'dd/mm HH:MM:ss')}]`;
+  };
+  static errorText = chalk.bold.red;
+  static warningText = chalk.keyword('orange');
+  static successText = chalk.keyword('green');
+  static helpText = chalk.blue;
+  static highlightText = chalk.yellow;
+  static infoText = chalk.keyword('grey');
+  static standardText = chalk.keyword('white');
+  static boldText = chalk.bold;
+  static critical: LogMethod = content => {
+    const message = `${Logger.getPrefix()}  ${Logger.errorText(
+      '[CRITICAL]'
+    )} ${content}`;
+    console.log(message);
+  };
+  static error: LogErrorMethod = (content, err) => {
+    const message = `${Logger.getPrefix()} ${Logger.errorText(
+      `${Logger.isUserTerminal ? '❌' : '[ERROR]'} ${content}${
+        err ? `\n\n${JSON.stringify(err, null, 2)}` : ''
+      }`
+    )}\n`;
+    if (progress.active) progress.current.interrupt(message);
+    else console.log(message);
+  };
+  static warning: LogMethod = content => {
+    // if (process.env.DEBUG === 'true') {
+    const message = `${Logger.getPrefix()} ${Logger.warningText(
+      `${Logger.isUserTerminal ? '⚠️ ' : '[WARN]'} ${content}`
+    )}\n`;
+    if (progress.active) progress.current.interrupt(message);
+    else console.log(message);
+    // }
+  };
+  static success: LogMethod = content => {
+    const message = `${Logger.getPrefix()} ${Logger.successText(
+      `${Logger.isUserTerminal ? '✅' : '[OK]'} ${content}`
+    )}`;
+    if (progress.active) progress.current.interrupt(message);
+    else console.log(message);
+  };
+  static info: LogMethod = content => {
+    const message = `${Logger.getPrefix()} ${
+      Logger.isUserTerminal ? chalk.bgCyan(' ℹ ') : '[INFO]'
+    } ${Logger.infoText(content)}`;
+    if (progress.active) progress.current.interrupt(message);
+    else console.log(message);
+  };
+  static help: LogMethod = content => {
+    const message = `${Logger.getPrefix()} ${chalk.blue(
+      `${Logger.isUserTerminal ? '⏩' : '[HELP]'} ${content}`
+    )}\n`;
+    if (progress.active) progress.current.interrupt(message);
+    else console.log(message);
+  };
+  static standard: LogMethod = content => {
+    const message = `${Logger.getPrefix()} ${
+      Logger.isUserTerminal ? '◻️' : '[STD]'
+    } \n${Logger.standardText(content)}`;
+    if (progress.active) progress.current.interrupt(message);
+    else console.log(message);
+    progress.current.interrupt(message);
+  };
+  static json: LogJsonMethod = (content, depth = 9) =>
+    console.dir(deepCleaner(content), { colors: true, depth });
+  static mixed: LogArrayMethod = contentArray =>
+    console.log(`${Logger.getPrefix()} ${contentArray.join(' ')}`);
+  static line = () =>
+    Logger.raw(`  ${Logger.infoText(`-------------------------------------`)}`);
+
+  static object: LogJsonMethod = 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)) {
+          for (const field of value || []) {
+            Logger.raw(
+              `    ${chalk.bold(field.id)}: ${chalk.grey(field.dataType)}`
+            );
+          }
+        } else if (key === 'groups' && Array.isArray(value)) {
+          for (const group of value || []) {
+            const description =
+              Object.keys(group.description).length &&
+              Object.values(group.description)?.[0];
+            Logger.raw(
+              `    ${chalk.bold(group.id)}${
+                description
+                  ? `: ${chalk.grey(Object.values(group.description)?.[0])}`
+                  : ''
+              }`
+            );
+          }
+        } else {
+          for (const [innerkey, innervalue] of Object.entries(value)) {
+            if (innervalue && typeof innervalue === 'object') {
+              Logger.raw(`    ${chalk.bold.grey(innerkey)}:`);
+              console.table(innervalue);
+            } else if (
+              typeof innervalue !== 'undefined' ||
+              innervalue !== null
+            ) {
+              Logger.raw(`    ${chalk.bold.grey(innerkey)}: ${innervalue}`);
+            }
+          }
+        }
+      } else if (typeof value !== 'undefined' || value !== null) {
+        Logger.raw(`  ${chalk.bold.grey(key)}: ${value}`);
+      }
+    }
+  };
+  static raw: LogMethod = (content: string) => {
+    if (progress.active) progress.current.interrupt(content);
+    else console.log(content);
+  };
+}
+
+export const logError: LogErrorFunc = (
+  err = new Error('Undefined error'),
+  msg,
+  level = 'error'
+) => {
+  Logger[level](msg || err.message || err?.data?.message || err.Message);
+  (Array.isArray(err) ? err : [err]).map((error: AppError) => {
+    if ('stack' in error) Logger.raw(`  ${Logger.infoText(error.stack)}`);
+    if ('data' in error)
+      Logger.raw(`  ${Logger.infoText(tryStringify(error.data))}`);
+  });
+  //Logger.line();
+  return null;
+};
+
+export const progress = {
+  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,
+  }),
+};