contensis-cli 1.0.0-beta.10 → 1.0.0-beta.100

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,26 +135,52 @@ class ContensisShell {
       availableCommands.push('login', 'list projects', 'set project');
     if (userId)
       availableCommands.push(
+        'create key',
+        'create project',
+        'create role',
+        'diff models',
+        'execute block action release',
+        'execute block action makelive',
+        'execute block action rollback',
+        'execute block action markasbroken',
         'get block',
         'get block logs',
         'get contenttype',
         'get component',
         'get entries',
+        'get nodes',
+        'get model',
+        'get project',
+        'get role',
+        'get token',
+        'get version',
+        'get webhook',
         'import contenttypes',
         'import components',
         'import entries',
+        'import models',
         'list blocks',
         'list contenttypes',
         'list components',
-        'list models',
         'list keys',
+        'list models',
+        'list proxies',
+        'list renderers',
+        'list roles',
         'list webhooks',
-        'create key',
         'push block',
-        'remove key',
-        'remove entry',
+        'remove components',
         'remove contenttypes',
-        'remove components'
+        'remove key',
+        'remove entries',
+        'remove role',
+        'set project name',
+        'set project description',
+        'set role name',
+        'set role description',
+        'set role assignments',
+        'set role enabled',
+        'set role permissions'
       );
 
     const prompt = inquirer.createPromptModule();
@@ -155,7 +189,7 @@ class ContensisShell {
       {
         type: 'command',
         name: 'cmd',
-        autoCompletion: availableCommands,
+        autoCompletion: availableCommands.sort(),
         autocompletePrompt: log.infoText(messages.app.autocomplete()),
         message: `${userId ? `${userId}@` : ''}${currentEnvironment || ''}>`,
         context: 0,
@@ -168,7 +202,7 @@ class ContensisShell {
             return true;
           }
         },
-        prefix: `${env?.currentProject || 'contensis'}`,
+        prefix: `${env?.currentProject || log.infoText('contensis')}`,
         short: true,
       },
     ])
@@ -191,7 +225,14 @@ class ContensisShell {
           } catch (ex: any) {
             const str = ex.toString();
             if (!str.includes('CommanderError'))
-              logError(ex, `Shell ${ex.toString()}`);
+              logError(
+                ex,
+                `Shell ${
+                  ex instanceof Error
+                    ? ex.toString()
+                    : JSON.stringify(ex, null, 2)
+                }`
+              );
           } finally {
             return this.contensisPrompt();
           }
@@ -221,7 +262,14 @@ 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 {
+      quit: ContensisCli.quit,
+      restart() {},
+    } as any;
   if (!globalShell) globalShell = new ContensisShell();
   return globalShell;
 };
@@ -232,12 +280,14 @@ process.on('uncaughtException', function (err) {
 });
 
 process.on('SIGINT', () => {
-  console.log('catching SIGINT');
+  Logger.warning('received SIGINT');
   shell().quit();
+  // setTimeout(() => {
+  // }, 2000);
 });
 
 process.on('SIGTERM', () => {
-  console.log('catching SIGTERM');
+  Logger.warning('received SIGTERM');
   shell().quit();
 });
 

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/diff.ts

@@ -0,0 +1,124 @@
+import chalk from 'chalk';
+import { Change, diffLines } from 'diff';
+import { normaliseLineEndings } from './os';
+
+export const diffLogStrings = (updates: string, previous: string) => {
+  const lastFewLines = previous.split('\n').slice(-10);
+  const incomingLines = updates.split('\n');
+
+  // Find the line indices in the incoming lines
+  // of the last few lines previously rendered
+  const incomingLineIndices = [];
+  for (const lastRenderedLine of lastFewLines) {
+    if (lastRenderedLine.length > 10)
+      incomingLineIndices.push(incomingLines.lastIndexOf(lastRenderedLine));
+  }
+
+  // Get the new lines from the next position on from the last of the already shown lines
+  const differentFromPos = Math.max(...incomingLineIndices, 0) + 1;
+  // Return just the incoming lines from the position we matched
+  return incomingLines.slice(differentFromPos).join('\n');
+};
+
+export const diffFileContent = (
+  existingContent: string,
+  newContent: string
+) => {
+  const existingContentNormalised = normaliseLineEndings(existingContent, '\n');
+  const newContentNormalised = normaliseLineEndings(newContent, '\n');
+
+  const diff = diffLines(existingContentNormalised, newContentNormalised, {
+    newlineIsToken: true,
+  });
+  const diffRanges = addDiffPositionInfo(diff);
+
+  // Create formatted output for console
+  const output: string[] = [];
+  const lnSpaceLength = Math.max(
+    ...diffRanges.map(d => d.startLineNumber.toString().length),
+    0
+  );
+
+  const lnSpaces = Array(lnSpaceLength).join(' ');
+
+  let needsNewLine = false;
+  for (let i = 0; i < diffRanges.length; i++) {
+    const part = diffRanges[i];
+    if (part.added || part.removed) {
+      const colour = part.added ? 'green' : part.removed ? 'red' : 'grey';
+
+      if (part.value !== '\n') {
+        if (needsNewLine) {
+          output.push('\n### --');
+          needsNewLine = false;
+        }
+        output.push(
+          `\n${part.value
+            .split('\n')
+            .map((ln, idx) =>
+              ln.trim() !== ''
+                ? `${
+                    part.startLineNumber ? part.startLineNumber + idx : lnSpaces
+                  }${part.added ? '+' : part.removed ? '-' : ' '} ${chalk[
+                    colour
+                  ](`${ln}`)}`
+                : ln
+            )
+            .join('\n')}`
+        );
+      } else needsNewLine = true;
+    } else needsNewLine = true;
+  }
+
+  return output.join('');
+};
+
+const addDiffPositionInfo = (diff: Change[]) => {
+  const diffRanges: (Change & {
+    startLineNumber: number;
+    startColumn: number;
+    endLineNumber: number;
+    endColumn: number;
+  })[] = [];
+
+  let lineNumber = 0;
+  let column = 0;
+  for (let partIndex = 0; partIndex < diff.length; partIndex++) {
+    const part = diff[partIndex];
+
+    // // Skip any parts that aren't in `after`
+    // if (part.removed === true) {
+    //   continue;
+    // }
+
+    const startLineNumber = lineNumber;
+    const startColumn = column;
+
+    // Split the part into lines. Loop throug these lines to find
+    // the line no. and column at the end of this part.
+    const substring = part.value;
+    const lines = substring.split('\n');
+    lines.forEach((line, lineIndex) => {
+      // The first `line` is actually just a continuation of the last line
+      if (lineIndex === 0) {
+        column += line.length;
+        // All other lines come after a line break.
+      } else if (lineIndex > 0) {
+        lineNumber += 1;
+        column = line.length;
+      }
+    });
+
+    // Save a range for all of the parts with position info added
+    if (part.added === true || part.removed === true) {
+      diffRanges.push({
+        startLineNumber: startLineNumber + 1,
+        startColumn: startColumn,
+        endLineNumber: lineNumber,
+        endColumn: column,
+        ...part,
+      });
+    }
+  }
+  return diffRanges;
+};

package/src/util/dotenv.ts

@@ -0,0 +1,37 @@
+import { EnvContentsToAdd } from "~/models/DevService";
+
+export const mergeDotEnvFileContents = (
+  existingFileLines: string[],
+  envContentsToAdd: EnvContentsToAdd
+): string[] => {
+  const envFileLines: string[] = []; // the new .env file
+  if (existingFileLines.length === 0) {
+    // There is no env file, just create one from envContentsToAdd
+    envFileLines.push(
+      ...Object.entries(envContentsToAdd).map(([k, v]) => `${k}=${v}`)
+    );
+  } else {
+    const updatedEnvKeys: string[] = [];
+    // Find lines in env that already exist for the keys in envContentsToAdd
+    // update them if they exist and add them to envFileLines
+    for (const ln of existingFileLines) {
+      let newline = '';
+      for (const [k, v] of Object.entries(envContentsToAdd))
+        if (ln.startsWith(`${k}=`)) {
+          newline = `${k}=${v}`;
+          updatedEnvKeys.push(k);
+        }
+      // Ensure an updated line or other lines from the existing env file are re-added
+      if (newline || ln) envFileLines.push(newline || ln);
+    }
+
+    // Add the envContentsToAdd lines to the file that did not previously exist or had an update
+    for (const addKey of Object.keys(envContentsToAdd).filter(
+      efl =>
+        !updatedEnvKeys.find(uek => uek.startsWith(`${efl.split('=')?.[0]}`))
+    ) as (keyof typeof envContentsToAdd)[]) {
+      envFileLines.push(`${addKey}=${envContentsToAdd[addKey]}`);
+    }
+  }
+  return envFileLines;
+};