contensis-cli 1.0.0-beta.89 → 1.0.0-beta.90

package/src/services/ContensisDevService.ts

@@ -2,18 +2,26 @@ import to from 'await-to-js';
 import { execFile, spawn } from 'child_process';
 import inquirer from 'inquirer';
 import path from 'path';
-import { Entry, Role } from 'contensis-management-api/lib/models';
+import { parse, stringify } from 'yaml';
 
+import { Role } from 'contensis-management-api/lib/models';
 import { MigrateRequest } from 'migratortron';
-import { stringify } from 'yaml';
-import ContensisCli from './ContensisCliService';
+
 import ContensisRole from './ContensisRoleService';
 import { OutputOptionsConstructorArg } from '~/models/CliService';
-import { mapSiteConfigYaml } from '~/mappers/ContensisCliService-to-RequestHanderSiteConfigYaml';
+import { EnvContentsToAdd } from '~/models/DevService';
+import { mapSiteConfigYaml } from '~/mappers/DevRequests-to-RequestHanderSiteConfigYaml';
+import {
+  deployKeyRole,
+  devKeyRole,
+} from '~/mappers/DevInit-to-RolePermissions';
 import { appRootDir, readFile, writeFile } from '~/providers/file-provider';
 import { jsonFormatter } from '~/util/json.formatter';
 import { GitHelper } from '~/util/git';
 import { findByIdOrName } from '~/util/find';
+import { mergeDotEnvFileContents } from '~/util/dotenv';
+import { mapCIWorkflowContent } from '~/mappers/DevInit-to-CIWorkflow';
+import { diffFileContent } from '~/util/diff';
 
 class ContensisDev extends ContensisRole {
   constructor(
@@ -53,14 +61,11 @@ class ContensisDev extends ContensisRole {
 
       const devKeyName = `${git.name} development`;
       const devKeyDescription = `${git.name} [contensis-cli]`;
-      const devKeyPermissions = { blocks: [] } as Partial<Role['permissions']>;
       let existingDevKey = apiKeyExists(devKeyName);
 
       const deployKeyName = `${git.name} deployment`;
       const deployKeyDescription = `${git.name} deploy [contensis-cli]`;
-      const deployKeyPermissions = { blocks: ['push', 'release'] } as Partial<
-        Role['permissions']
-      >;
+
       let existingDeployKey = apiKeyExists(deployKeyName);
 
       const blockId = git.name;
@@ -97,34 +102,39 @@ class ContensisDev extends ContensisRole {
         ({ ciFileName } = await inquirer.prompt([
           {
             type: 'list',
-            message: `Multiple GitHub workflow files found\n${log.infoText(
-              `Tell us which GitHub workflow builds the container image after each push:`
-            )}`,
+            message: messages.devinit.ciMultipleChoices(),
             name: 'ciFileName',
             choices: workflowFiles,
             default: workflowFiles.find(f => f.includes('docker')),
           },
         ]));
         log.raw('');
+        git.ciFileName = ciFileName;
       }
 
       log.raw(log.infoText(messages.devinit.ciDetails(ciFileName)));
-      ylog.help(messages.devinit.ciIntro(git));
 
-      // Confirm prompt
-      const { confirm } = await inquirer.prompt([
-        {
-          type: 'confirm',
-          message: messages.devinit.confirm(),
-          name: 'confirm',
-          default: false,
-        },
-      ]);
-      log.raw('');
-      if (!confirm) return;
+      // Look at the workflow file content and make updates
+      const mappedWorkflow = mapCIWorkflowContent(this, git);
+
+      log.help(messages.devinit.ciIntro(git));
+
+      if (!dryRun) {
+        // Confirm prompt
+        const { confirm } = await inquirer.prompt([
+          {
+            type: 'confirm',
+            message: messages.devinit.confirm(),
+            name: 'confirm',
+            default: false,
+          },
+        ]);
+        log.raw('');
+        if (!confirm) return;
+      }
 
       // Access token prompt
-      const { accessToken } = await inquirer.prompt([
+      const { accessToken }: { accessToken: string } = await inquirer.prompt([
         {
           type: 'input',
           message: messages.devinit.accessTokenPrompt(),
@@ -167,10 +177,7 @@ class ContensisDev extends ContensisRole {
           | undefined;
         existingDevRole = await this.CreateOrUpdateRole(
           existingDevRole,
-          devKeyName,
-          devKeyDescription,
-          { apiKeys: [devKeyName] },
-          devKeyPermissions
+          devKeyRole(devKeyName, devKeyDescription)
         );
         checkpoint('dev key role assigned');
         log.success(messages.devinit.createDevKey(devKeyName, true));
@@ -183,10 +190,7 @@ class ContensisDev extends ContensisRole {
         ) as Role | undefined;
         existingDeployRole = await this.CreateOrUpdateRole(
           existingDeployRole,
-          deployKeyName,
-          deployKeyDescription,
-          { apiKeys: [deployKeyName] },
-          deployKeyPermissions
+          deployKeyRole(deployKeyName, deployKeyDescription)
         );
 
         checkpoint('deploy key role assigned');
@@ -195,42 +199,31 @@ class ContensisDev extends ContensisRole {
       }
 
       // Update or create a file called .env in project home
-      const envContents = {
+      const envContentsToAdd: EnvContentsToAdd = {
         ALIAS: currentEnv,
         PROJECT: currentProject,
-        ACCESS_TOKEN: accessToken,
       };
+      if (accessToken) envContentsToAdd['ACCESS_TOKEN'] = accessToken;
+
       const envFilePath = `${projectHome}/.env`;
       const existingEnvFile = readFile(envFilePath);
-      const existingFileLines = (existingEnvFile || '').split('\n');
-      const envFileLines: string[] = [];
-
-      const updatedEnvKeys: string[] = [];
-      for (const ln of existingFileLines) {
-        let newline = '';
-        for (const [k, v] of Object.entries(envContents))
-          if (ln.startsWith(`${k}=`)) {
-            newline = `${k}=${v}`;
-            updatedEnvKeys.push(k);
-          }
-        envFileLines.push(newline || ln);
-      }
-      for (const addKey of existingFileLines
-        .filter(
-          efl =>
-            !updatedEnvKeys.find(uek =>
-              uek.startsWith(`${efl.split('=')?.[0]}=`)
-            ) && Object.keys(envContents).find(ck => ck === efl.split('=')?.[0])
-        )
-        .map(fl => fl.split('=')?.[0]) as (keyof typeof envContents)[]) {
-        envFileLines.push(`${addKey}=${envContents[addKey]}`);
-      }
+      const envFileLines = mergeDotEnvFileContents(
+        (existingEnvFile || '').split('\n').filter(l => !!l),
+        envContentsToAdd
+      );
+      const envDiff = diffFileContent(
+        existingEnvFile || '',
+        envFileLines.join('\n')
+      );
 
       if (dryRun) {
+        if (envDiff) {
+          log.info(`updating .env file ${envFilePath}: ${envDiff}`);
+          log.raw('');
+        }
         checkpoint('skip .env file update (dry-run)');
-        log.info(`.env file`);
-        log.object(envFileLines);
       } else {
+        if (envDiff) log.info(`updating .env file ${envFilePath}`);
         writeFile(envFilePath, envFileLines.join('\n'));
         checkpoint('.env file updated');
         log.success(messages.devinit.writeEnvFile());
@@ -239,11 +232,15 @@ class ContensisDev extends ContensisRole {
 
       // Update CI file -- different for GH/GL -- create a sample one with build?
       if (dryRun) {
+        if (mappedWorkflow?.diff) {
+          log.info(`updating${ciFileName} file: ${mappedWorkflow.diff}`);
+          log.raw('');
+        }
         checkpoint('skip CI file update (dry-run)');
-        log.info(`${ciFileName} file`);
-        // TODO: log what we might add to the file
-        //log.object(envFileLines);
+        //log.object(ciFileLines);
       } else {
+        if (mappedWorkflow?.diff) log.info(`updating${ciFileName} file`);
+        writeFile(git.ciFilePath, [].join('\n'));
         log.success(messages.devinit.writeCiFile(`./${ciFileName}`));
         log.info(
           messages.devinit.ciBlockTip(blockId, currentEnv, currentProject)
@@ -261,8 +258,13 @@ class ContensisDev extends ContensisRole {
         )
       );
 
-      log.success(messages.devinit.success());
-      log.help(messages.devinit.startProjectTip());
+      if (dryRun) {
+        log.success(messages.devinit.dryRun());
+        log.help(messages.devinit.noChanges());
+      } else {
+        log.success(messages.devinit.success());
+        log.help(messages.devinit.startProjectTip());
+      }
     }
   };
 

package/src/services/ContensisRoleService.ts

@@ -44,10 +44,7 @@ class ContensisRole extends ContensisCli {
 
   CreateOrUpdateRole = async (
     existingRole: Role | undefined,
-    name: string,
-    description: string,
-    assignments: Role['assignments'],
-    permissions: Role['permissions']
+    role: Partial<Role>
   ) => {
     const { contensis, currentEnv, messages } = this;
     if (!contensis) throw new Error('shouldnt be here');
@@ -56,24 +53,19 @@ class ContensisRole extends ContensisCli {
       // TODO: check is update needed?
       const [err, updated] = await contensis.roles.UpdateRole(existingRole.id, {
         ...existingRole,
-        assignments,
-        permissions,
+        ...role,
       });
       if (err)
-        throw new Error(messages.roles.failedSet(currentEnv, name), {
+        throw new Error(messages.roles.failedSet(currentEnv, role.name), {
           cause: err,
         });
       return updated;
     } else {
-      const [err, created] = await contensis.roles.CreateRole({
-        name,
-        description,
-        enabled: true,
-        assignments,
-        permissions,
-      } as Role);
+      const [err, created] = await contensis.roles.CreateRole(
+        role as Omit<Role, 'id'>
+      );
       if (err)
-        throw new Error(messages.roles.failedCreate(currentEnv, name), {
+        throw new Error(messages.roles.failedCreate(currentEnv, role.name), {
           cause: err,
         });
 

package/src/util/diff.ts

@@ -1,3 +1,7 @@
+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');
@@ -15,3 +19,95 @@ export const diffLogStrings = (updates: string, previous: string) => {
   // 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/git.ts

@@ -14,18 +14,30 @@ 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.workflows
-      ? this.type === 'github'
-        ? this.workflows.length > 1
-          ? '[multiple workflows]'
-          : this.workflows?.[0]
-        : GITLAB_CI_FILENAME
-      : '[unknown]';
+    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 (

package/src/util/logger.ts

@@ -90,11 +90,13 @@ export class Logger {
     progress.current.interrupt(message);
   };
   static debug: LogMethod = content => {
-    const message = `${Logger.getPrefix()} ${
-      Logger.isUserTerminal ? chalk.bgGrey(' ⚙ ') : '[DEBUG]'
-    } ${Logger.infoText(content)}`;
-    if (progress.active) progress.current.interrupt(message);
-    else console.log(message);
+    if (['true', '1'].includes(process.env.debug || '')) {
+      const message = `${Logger.getPrefix()} ${
+        Logger.isUserTerminal ? chalk.bgGrey(' ⚙ ') : '[DEBUG]'
+      } ${Logger.infoText(content)}`;
+      if (progress.active) progress.current.interrupt(message);
+      else console.log(message);
+    }
   };
   static json: LogJsonDepthMethod = (content, depth = 9) =>
     console.dir(deepCleaner(content), { colors: true, depth });
@@ -251,6 +253,10 @@ export const logError: LogErrorFunc = (
 ) => {
   Logger[level](msg || err.message || err?.data?.message || err.Message);
   (Array.isArray(err) ? err : [err]).map((error: AppError) => {
+    if (typeof error === 'string') {
+      Logger.raw(`${Logger.infoText(error)}\n`);
+      return;
+    }
     if ('stack' in error) Logger.raw(`  ${Logger.infoText(error.stack)}\n`);
     if ('data' in error)
       Logger.raw(`  ${Logger.infoText(tryStringify(error.data))}\n`);

package/src/util/yaml.ts

@@ -0,0 +1,13 @@
+import { validateWorkflow } from '@action-validator/core';
+
+import { parse, parseDocument, stringify } from 'yaml';
+
+export const parseYaml = parse;
+export const parseYamlDocument = parseDocument;
+export const stringifyYaml = stringify;
+
+export const validateWorkflowYaml = (yaml: string) => {
+  const { actionType, errors } = validateWorkflow(yaml);
+  if (actionType && errors.length === 0) return true;
+  return errors;
+};

package/src/version.ts

@@ -1 +1 @@
-export const LIB_VERSION = "1.0.0-beta.89";
+export const LIB_VERSION = "1.0.0-beta.90";