contensis-cli 1.0.0-beta.6 → 1.0.0-beta.61

package/src/shell.ts

@@ -1,13 +1,14 @@
-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 { appRootDir } from './providers/file-provider';
 import ContensisCli, { cliCommand } from './services/ContensisCliService';
 import { Logging } from './util';
+import { logError, Logger } from './util/logger';
+import { LIB_VERSION } from './version';
 
 class ContensisShell {
   private currentEnvironment!: string;
@@ -39,12 +40,11 @@ class ContensisShell {
     inquirerPrompt.setConfig({
       history: {
         save: true,
-        folder: path.join(__dirname, '../'),
+        folder: appRootDir,
         limit: 100,
         blacklist: ['quit'],
       },
     });
-    // inquirer.registerPrompt('command', inquirerPrompt);
 
     const { log, messages } = this;
 
@@ -64,7 +64,7 @@ class ContensisShell {
           return;
         }
         console.log(log.successText(data));
-        console.log(log.infoText(messages.app.startup()));
+        console.log(log.infoText(messages.app.startup(LIB_VERSION)));
         console.log(log.helpText(messages.app.help()));
 
         this.start().catch(ex => log.error(ex));
@@ -72,8 +72,13 @@ class ContensisShell {
     );
   }
 
+  restart = async () => {
+    this.firstStart = false;
+    this.log.line(); // add a line so we can see where the shell has been restarted
+    await this.start();
+  };
+
   start = async () => {
-    this.log.line();
     this.refreshEnvironment();
     this.userId = '';
     const { currentEnvironment, env, log, messages } = this;
@@ -98,7 +103,10 @@ class ContensisShell {
               silent: true,
             }
           );
-          if (token) this.userId = env.lastUserId;
+          if (token) {
+            this.userId = env.lastUserId;
+            if (!env.currentProject) log.warning(messages.projects.tip());
+          }
           this.firstStart = false;
           this.refreshEnvironment();
         } else {
@@ -127,14 +135,20 @@ class ContensisShell {
       availableCommands.push('login', 'list projects', 'set project');
     if (userId)
       availableCommands.push(
+        'create project',
+        'diff models',
         'get block',
         'get block logs',
         'get contenttype',
         'get component',
         'get entries',
+        'get model',
+        'get project',
+        'get version',
         'import contenttypes',
         'import components',
         'import entries',
+        'import models',
         'list blocks',
         'list contenttypes',
         'list components',
@@ -143,10 +157,13 @@ class ContensisShell {
         'list webhooks',
         'create key',
         'push block',
+        'release block',
         'remove key',
-        'remove entry',
+        'remove entries',
         'remove contenttypes',
-        'remove components'
+        'remove components',
+        'set project name',
+        'set project description'
       );
 
     const prompt = inquirer.createPromptModule();
@@ -168,7 +185,7 @@ class ContensisShell {
             return true;
           }
         },
-        prefix: `${env?.currentProject || 'contensis'}`,
+        prefix: `${env?.currentProject || log.infoText('contensis')}`,
         short: true,
       },
     ])
@@ -221,7 +238,10 @@ class ContensisShell {
 let globalShell: ContensisShell;
 
 export const shell = () => {
-  if (typeof process.argv?.[2] !== 'undefined') return { start() {} } as any;
+  // Return a benign function for shell().restart() when used in cli context
+  // as some commands need to restart the shell to show an updated prompt
+  // after successful connect / login / set project
+  if (typeof process.argv?.[2] !== 'undefined') return { restart() {} } as any;
   if (!globalShell) globalShell = new ContensisShell();
   return globalShell;
 };

package/src/util/console.printer.ts

@@ -1,6 +1,7 @@
 import dayjs from 'dayjs';
-import { BlockVersion, MigrateStatus } from 'migratortron';
+import { BlockVersion, MigrateModelsResult, MigrateStatus } from 'migratortron';
 import ContensisCli from '~/services/ContensisCliService';
+import { Logger } from './logger';
 
 const formatDate = (date: Date | string, format = 'DD/MM/YYYY HH:mm') =>
   dayjs(date).format(format);
@@ -104,57 +105,22 @@ export const printBlockVersion = (
 };
 
 export const printMigrateResult = (
-  { log, messages, contensis, currentProject }: ContensisCli,
+  { log, messages, currentProject }: ContensisCli,
   migrateResult: any,
-  { action = 'import' }: { action?: 'import' | 'delete' } = {}
+  {
+    action = 'import',
+    showDiff = false,
+    showAllEntries = false,
+    showChangedEntries = false,
+  }: {
+    action?: 'import' | 'delete';
+    showDiff?: boolean;
+    showAllEntries?: boolean;
+    showChangedEntries?: boolean;
+  } = {}
 ) => {
   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]) {
@@ -162,42 +128,238 @@ export const printMigrateResult = (
       string,
       any
     ][]) {
+      if (
+        showAllEntries ||
+        (showChangedEntries &&
+          (
+            Object.entries(
+              Object.entries(entryStatus[currentProject])[0]
+            )[1][1] as any
+          ).status !== 'no change')
+      ) {
+        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.migrate.status(status)(`${status}`)}${
+                  targetGuid !== originalId ? `-> ${targetGuid}` : ''
+                }`;
+              })}`
+          ) + ` ${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 && showDiff) {
+            console.log(
+              `    ${log.highlightText(`diff:`)} ${log.infoText(
+                highlightDiffText(diff)
+              )}\n`
+            );
+          }
+        }
+      }
+    }
+  }
+  if (showAllEntries || showChangedEntries) console.log(``);
+
+  for (const [projectId, contentTypeCounts] of Object.entries(
+    migrateResult.entries || {}
+  ) as [string, any][]) {
+    log.help(
+      `${action} from project ${
+        action === 'delete'
+          ? log.warningText(currentProject)
+          : `${log.highlightText(projectId)} to ${log.boldText(
+              log.warningText(currentProject)
+            )}`
+      }`
+    );
+    for (const [contentTypeId, count] of Object.entries(contentTypeCounts) as [
+      string,
+      number
+    ][]) {
+      const isTotalCountRow = contentTypeId === 'totalCount';
+      const migrateStatusAndCount =
+        migrateResult.entriesToMigrate[currentProject][contentTypeId];
+      const existingCount =
+        migrateResult.existing?.[currentProject]?.[contentTypeId] || 0;
+      const existingPercent = ((existingCount / count) * 100).toFixed(0);
+      const noChangeOrTotalEntriesCount =
+        typeof migrateStatusAndCount !== 'number'
+          ? migrateStatusAndCount?.['no change'] || 0
+          : migrateStatusAndCount;
+
+      const changedPercentage = (
+        (noChangeOrTotalEntriesCount / count) *
+        100
+      ).toFixed(0);
+
+      const existingColor =
+        existingPercent === '0' || action === 'delete'
+          ? log.warningText
+          : log.infoText;
+
+      const changedColor = isTotalCountRow
+        ? log.helpText
+        : changedPercentage === '100'
+        ? log.successText
+        : log.warningText;
+
       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}` : ''}`;
-            })}]`
-        )
+        `  - ${
+          isTotalCountRow
+            ? log.highlightText(
+                `${contentTypeId}: ${noChangeOrTotalEntriesCount}`
+              )
+            : `${contentTypeId}: ${log.helpText(count)}`
+        }${
+          changedPercentage === '100' || isTotalCountRow
+            ? ''
+            : existingColor(` [existing: ${`${existingPercent}%`}]`)
+        }${
+          existingPercent === '0' || (action === 'import' && isTotalCountRow)
+            ? ''
+            : changedColor(
+                ` ${
+                  isTotalCountRow
+                    ? `[to ${action}: ${noChangeOrTotalEntriesCount}]`
+                    : changedPercentage === '100'
+                    ? 'up to date'
+                    : `[needs update: ${100 - Number(changedPercentage)}%]`
+                }`
+              )
+        }`
+      );
+    }
+  }
+  if (migrateResult.errors?.length) {
+    console.log(
+      `  - ${log.errorText(`errors: ${migrateResult.errors.length}`)}\n`
+    );
+    for (const error of migrateResult.errors)
+      log.error(error.message || error, null, '');
+  }
+};
+
+const highlightDiffText = (str: string) => {
+  const addedRegex = new RegExp(/<<\+>>(.*?)<<\/\+>>/, 'g');
+  const removedRegex = new RegExp(/<<->>(.*?)<<\/->>/, 'g');
+  return str
+    .replace(addedRegex, match => {
+      return Logger.successText(
+        match.replace(/<<\+>>/g, '<+>').replace(/<<\/\+>>/g, '</+>')
+      );
+    })
+    .replace(removedRegex, match => {
+      return Logger.errorText(
+        match.replace(/<<->>/g, '<->').replace(/<<\/->>/g, '</->')
       );
-      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)}`
+export const printModelMigrationAnalysis = (
+  { log, messages }: ContensisCli,
+  result: any = {}
+) => {
+  for (const [contentTypeId, model] of Object.entries(result) as [
+    string,
+    any
+  ][]) {
+    let mainOutput = log.standardText(`  - ${contentTypeId}`);
+    let extraOutput = '';
+    let errorOutput = '';
+    let diffOutput = '';
+    for (const [key, details] of Object.entries(model) as [string, any][]) {
+      if (key === 'dependencies') {
+        extraOutput += log.infoText(
+          `      references: [${details?.join(', ')}]\n`
+        );
+      }
+      if (key === 'dependencyOf') {
+        extraOutput += log.infoText(
+          `      required by: [${details?.join(', ')}]\n`
+        );
+      }
+      if (key === 'projects') {
+        for (const [projectId, projectDetails] of Object.entries(details) as [
+          string,
+          any
+        ][]) {
+          mainOutput += log.infoText(
+            ` [${messages.migrate.status(projectDetails.status)(
+              `${projectId}: ${projectDetails.status}`
+            )}] v${projectDetails.versionNo}`
           );
-          console.log(``);
-          console.log(log.highlightText(diff));
+          if (projectDetails.diff)
+            diffOutput += `      ${log.highlightText(`diff:`)} ${log.infoText(
+              highlightDiffText(projectDetails.diff)
+            )}\n`;
+          if (projectDetails.error)
+            errorOutput += `      ${log.highlightText(
+              `error::`
+            )} ${log.errorText(projectDetails.error)}`;
         }
       }
     }
+    console.log(mainOutput);
+    if (extraOutput) {
+      const search = '\n';
+      const replace = '';
+      console.log(
+        extraOutput.replace(
+          new RegExp(search + '([^' + search + ']*)$'),
+          replace + '$1'
+        )
+      );
+    }
+    if (diffOutput) console.log(diffOutput);
+    if (errorOutput) console.log(errorOutput);
+  }
+};
+
+type MigrateResultSummary = MigrateModelsResult['']['contentTypes'];
+type MigrateResultStatus = keyof MigrateResultSummary;
+
+export const printModelMigrationResult = (
+  { log, messages }: ContensisCli,
+  result: MigrateResultSummary
+) => {
+  for (const [status, ids] of Object.entries(result) as [
+    MigrateResultStatus,
+    string[]
+  ][]) {
+    if (ids?.length) {
+      if (status === 'errors') {
+        const errors: [string, MappedError][] = ids as any;
+        log.raw(
+          `  - ${status}: [ ${messages.migrate.models.result(status)(
+            ids.map(id => id[0]).join(', ')
+          )} ]\n`
+        );
+        for (const [contentTypeId, error] of errors)
+          log.error(
+            `${log.highlightText(contentTypeId)}: ${error.message}`,
+            error
+          );
+      } else
+        log.raw(
+          `  - ${status}: [ ${messages.migrate.models.result(status)(
+            ids.join(', ')
+          )} ]`
+        );
+    }
   }
 };

package/src/util/index.ts

@@ -1,5 +1,6 @@
 import mergeWith from 'lodash/mergeWith';
 import { Logger } from './logger';
+import { LogMessages as enGB } from '../localisation/en-GB.js';
 
 export const isSharedSecret = (str = '') =>
   str.length > 80 && str.split('-').length === 3 ? str : undefined;
@@ -50,12 +51,17 @@ export const url = (alias: string, project: string) => {
 };
 
 export const Logging = async (language = 'en-GB') => {
-  const { LogMessages: defaultMessages } = await import(
-    `../localisation/en-GB.js`
-  );
-  const { LogMessages: localisedMessages } = await import(
-    `../localisation/${language}.js`
-  );
+  const defaultMessages = enGB;
+  // const { LogMessages: defaultMessages } = await import(
+  //   `../localisation/en-GB.js`
+  // );
+  let localisedMessages = defaultMessages;
+
+  if (language === 'en-GB') {
+    // Using a variable import e.g. `import(`../localisation/${language}.js`);`
+    // does not play well with packaged executables
+    // So we have to hard code the import for each language individually
+  }
   return {
     messages: mergeWith(
       localisedMessages,

package/src/util/logger.ts

@@ -6,8 +6,9 @@ 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 LogErrorMethod = (content: string, err?: any, newline?: string) => void;
+type LogJsonMethod = (content: any, depth?: number, indent?: string) => void;
+type LogJsonDepthMethod = (content: any, depth: number) => void;
 type LogArrayMethod = (contentArray: string[]) => void;
 type LogErrorFunc = (
   err: any,
@@ -36,12 +37,12 @@ export class Logger {
     )} ${content}`;
     console.log(message);
   };
-  static error: LogErrorMethod = (content, err) => {
+  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)}` : ''
       }`
-    )}\n`;
+    )}${newline}`;
     if (progress.active) progress.current.interrupt(message);
     else console.log(message);
   };
@@ -83,7 +84,7 @@ export class Logger {
     else console.log(message);
     progress.current.interrupt(message);
   };
-  static json: LogJsonMethod = (content, depth = 9) =>
+  static json: LogJsonDepthMethod = (content, depth = 9) =>
     console.dir(deepCleaner(content), { colors: true, depth });
   static mixed: LogArrayMethod = contentArray =>
     console.log(`${Logger.getPrefix()} ${contentArray.join(' ')}`);
@@ -97,7 +98,38 @@ export class Logger {
         if (key === 'fields' && Array.isArray(value)) {
           for (const field of value || []) {
             Logger.raw(
-              `    ${chalk.bold(field.id)}: ${chalk.grey(field.dataType)}`
+              `    ${chalk.bold(field.id)}${
+                field.id === content.entryTitleField
+                  ? '**'
+                  : field.validations.minCount?.value ||
+                    typeof field.validations.required?.message !== 'undefined'
+                  ? '*'
+                  : ''
+              }: ${chalk.grey(
+                `${field.dataType}${
+                  field.dataFormat
+                    ? `<${
+                        Array.isArray(
+                          field.validations.allowedFieldTypes?.fields
+                        )
+                          ? `composer[${field.validations.allowedFieldTypes.fields
+                              .map((f: any) => f.id)
+                              .join(' | ')}]`
+                          : field.dataFormat
+                      }${
+                        field.dataFormat === 'entry'
+                          ? `, ${field.validations.allowedContentTypes.contentTypes.join(
+                              ' | '
+                            )}`
+                          : ''
+                      }>`
+                    : ''
+                }${
+                  field.validations.maxLength?.value
+                    ? `(${field.validations.maxLength.value})`
+                    : ''
+                }`
+              )}`
             );
           }
         } else if (key === 'groups' && Array.isArray(value)) {
@@ -114,22 +146,59 @@ export class Logger {
             );
           }
         } 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}`);
+          Logger.objectRecurse(value, 3, '    ');
+          // 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) {
+        const valueText =
+          key === 'id' && typeof value === 'string'
+            ? Logger.highlightText(value)
+            : value;
+        Logger.raw(`  ${chalk.bold.grey(key)}: ${valueText}`);
+      }
+    }
+  };
+
+  static objectRecurse: LogJsonMethod = (content, depth = 3, indent = '') => {
+    if (Array.isArray(content)) {
+      for (const item of content) {
+        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.raw(`${indent}${item}`);
+      }
+    } else
+      for (const [key, value] of Object.entries(content)) {
+        if (Array.isArray(value)) {
+          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.raw(`${indent}  ${item}`);
             }
           }
+        } else if (value && typeof value === 'object') {
+          Logger.raw(`${indent}${chalk.bold.grey(key)}:`);
+
+          Logger.objectRecurse(value, depth + 1, `${indent}  `);
+          // console.table(value);
+        } else if (typeof value !== 'undefined' && value !== null) {
+          Logger.raw(`${indent}${chalk.bold.grey(key)}: ${value}`);
         }
-      } 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);

package/src/version.ts

@@ -1 +1 @@
-export const LIB_VERSION = "1.0.0-beta.6";
+export const LIB_VERSION = "1.0.0-beta.61";