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

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,113 @@
+import chalk from 'chalk';
+import { Change, diffLines } from 'diff';
+import { add } from 'lodash';
+
+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) + 1 || 0;
+  // Return just the incoming lines from the position we matched
+  return incomingLines.slice(differentFromPos).join('\n');
+};
+
+export const diffFileContent = (
+  existingContent: string,
+  newContent: string
+) => {
+  const diff = diffLines(existingContent, newContent, { 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)
+  );
+
+  const lnSpaces = Array(lnSpaceLength).join(' ');
+
+  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')
+        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')}`
+        );
+    }
+  }
+
+  return output.join('');
+  // return retOutput.endsWith('\n') ? retOutput : `${retOutput}\n`;
+};
+
+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;
+};

package/src/util/find.ts

@@ -0,0 +1,8 @@
+export const findByIdOrName = (arr: any[], idOrName: string, exact = false) =>
+  arr.find(
+    r =>
+      r.id === idOrName ||
+      r.name.toLowerCase() === idOrName.toLowerCase()
+  ) ||
+  (!exact &&
+    arr.find(r => r.name.toLowerCase().includes(idOrName.toLowerCase())));

package/src/util/git.ts

@@ -0,0 +1,130 @@
+import giturl from 'giturl';
+import hostedGitInfo from 'hosted-git-info';
+import parseGitConfig from 'parse-git-config';
+import path from 'path';
+
+import { linuxSlash } from './os';
+import { readFile, readFiles } from '~/providers/file-provider';
+
+const GITLAB_CI_FILENAME = '.gitlab-ci.yml';
+
+type GitConfig = parseGitConfig.Config;
+
+export type GitTypes = hostedGitInfo.Hosts;
+
+export class GitHelper {
+  private gitRepoPath: string;
+  private ciFile?: string;
+
+  config = {} as GitConfig;
+  info: hostedGitInfo | undefined;
+  home: string | undefined;
+
+  set ciFileName(fileName: string) {
+    this.ciFile = fileName;
+  }
+
+  get ciFileName() {
+    return (
+      this.ciFile ||
+      (this.workflows
+        ? this.type === 'github'
+          ? this.workflows.length > 1
+            ? '[multiple workflows]'
+            : this.workflows?.[0]
+          : GITLAB_CI_FILENAME
+        : '[unknown]')
+    );
+  }
+  get ciFilePath() {
+    return `${this.gitRepoPath}/${this.ciFileName}`;
+  }
+  get name() {
+    return (
+      this.info?.project || this.home?.split('/').pop() || '[set arg --name]'
+    );
+  }
+  get originUrl() {
+    return this.config.remote.origin.url;
+  }
+  get secretsUri() {
+    return `${
+      this.type === 'github'
+        ? `${this.home}/settings/secrets/actions`
+        : `${this.home}/-/settings/ci_cd`
+    }`;
+  }
+  get type() {
+    return this.info?.type || this.hostType();
+  }
+  get workflows() {
+    return this.type === 'github'
+      ? this.githubWorkflows()
+      : this.gitlabWorkflow();
+  }
+  constructor(gitRepoPath: string = process.cwd()) {
+    this.gitRepoPath = gitRepoPath;
+    this.config = this.gitConfig();
+    this.home = giturl.parse(this.originUrl);
+    this.info = this.gitInfo();
+    // console.log(this.config);
+    // console.log(this.home);
+    // console.log(this.info);
+  }
+  gitcwd = () => path.join(this.gitRepoPath);
+  gitInfo = (url: string = this.originUrl) => hostedGitInfo.fromUrl(url);
+  hostType = (url: string = this.originUrl): GitTypes => {
+    if (url.includes('github.com')) return 'github';
+    return 'gitlab';
+    // if (url.includes('gitlab.com')) return 'gl';
+    // if (url.includes('gitlab.zengenti.com')) return 'gl';
+  };
+  gitConfig = (cwd = this.gitRepoPath) => {
+    // Find .git/config in project cwd
+    const config = parseGitConfig.sync({
+      path: '.git/config',
+      expandKeys: true,
+    });
+    // console.log(cwd, config);
+    if (Object.keys(config || {}).length) return config;
+
+    // Recursively check the directory heirarchy for existance of a .git/config
+    const pathParts = linuxSlash(cwd).split('/');
+    for (let i = 1; i <= pathParts.length; i++) {
+      const relPath = `${Array(i).fill('..').join('/')}/.git/config`;
+      // Does not appear to work when using a shortened cwd, using relative path instead
+      const config = parseGitConfig.sync({
+        path: relPath,
+        expandKeys: true,
+      });
+      // console.log(relPath, config);
+      if (Object.keys(config || {}).length) {
+        this.gitRepoPath = path.join(
+          this.gitRepoPath,
+          Array(i).fill('..').join('/')
+        );
+        return config;
+      }
+    }
+    return config;
+  };
+  githubWorkflows = () => {
+    const workflowPath = path.join(this.gitcwd(), '.github/workflows');
+    const workflowFiles = readFiles(workflowPath, false);
+    // console.log('gh workflows: ', workflowFiles);
+    const addFolderSuffix = (files: string[]) =>
+      files.map(f => `.github/workflows/${f}`);
+
+    if (workflowFiles.some(f => f.includes('build')))
+      return addFolderSuffix(workflowFiles.filter(f => f.includes('build')));
+    return addFolderSuffix(workflowFiles);
+  };
+  gitlabWorkflow = (ciFileName = GITLAB_CI_FILENAME) => {
+    const workflowPath = this.gitcwd();
+    const workflowFilePath = path.join(workflowPath, ciFileName);
+    const workflowFile = readFile(workflowFilePath);
+    // console.log(ciFileName, workflowFile);
+
+    return workflowFile;
+  };
+}

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;
@@ -7,7 +8,7 @@ export const isSharedSecret = (str = '') =>
 export const isPassword = (str = '') =>
   !isSharedSecret(str) ? str : undefined;
 
-export const tryParse = (str: string) => {
+export const tryParse = (str: any) => {
   try {
     return typeof str === 'object' ? str : JSON.parse(str);
   } catch (e) {
@@ -26,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 =
@@ -50,12 +54,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,