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

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,131 @@
+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);
+    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')));
+    } else {
+      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,

package/src/util/logger.ts

@@ -2,12 +2,14 @@
 import chalk from 'chalk';
 import dateFormat from 'dateformat';
 import deepCleaner from 'deep-cleaner';
-import ProgressBar from 'progress';
-import { tryStringify } from '.';
+import { ansiEscapeCodes, first, strlen } from 'printable-characters';
+// import ProgressBar from 'progress';
+import { isSysError, 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 +38,16 @@ 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)}` : ''
+        err
+          ? `\n\n${Logger.infoText(
+              isSysError(err) ? err.toString() : JSON.stringify(err, null, 2)
+            )}`
+          : ''
       }`
-    )}\n`;
+    )}${newline}`;
     if (progress.active) progress.current.interrupt(message);
     else console.log(message);
   };
@@ -83,7 +89,16 @@ export class Logger {
     else console.log(message);
     progress.current.interrupt(message);
   };
-  static json: LogJsonMethod = (content, depth = 9) =>
+  static debug: LogMethod = content => {
+    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 });
   static mixed: LogArrayMethod = contentArray =>
     console.log(`${Logger.getPrefix()} ${contentArray.join(' ')}`);
@@ -91,13 +106,44 @@ export class Logger {
     Logger.raw(`  ${Logger.infoText(`-------------------------------------`)}`);
 
   static object: LogJsonMethod = content => {
-    for (const [key, value] of Object.entries(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)}`
+              `    ${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,20 +160,63 @@ 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 {
+      let pos = 0;
+      for (const [key, value] of Object.entries(content)) {
+        const thisIndent =
+          pos === 0 ? `${indent.substring(0, indent.length - 2)}- ` : indent;
+        if (Array.isArray(value)) {
+          if (value.length) Logger.raw(`${thisIndent}${chalk.bold.grey(key)}:`);
+          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(`${thisIndent}${chalk.bold.grey(key)}: ${value}`);
         }
-      } else if (typeof value !== 'undefined' || value !== null) {
-        Logger.raw(`  ${chalk.bold.grey(key)}: ${value}`);
+        pos++;
       }
     }
   };
@@ -135,6 +224,26 @@ export class Logger {
     if (progress.active) progress.current.interrupt(content);
     else console.log(content);
   };
+
+  static limits = (content: string, displayLength = 30) => {
+    const consoleWidth = process.stdout.columns;
+    console.info(
+      consoleWidth
+        ? content
+            .split('\n')
+            .slice(0, consoleWidth ? displayLength : undefined)
+            .map((line: string) =>
+              consoleWidth && strlen(line) > consoleWidth
+                ? first(line, consoleWidth)
+                : line
+            )
+            .join('\n')
+        : content.replace(ansiEscapeCodes, '')
+    );
+    const tableArray = content.split('\n');
+    if (consoleWidth && tableArray.length > displayLength)
+      console.info(`\n`, `- and ${tableArray.length - displayLength} more...`);
+  };
 }
 
 export const logError: LogErrorFunc = (
@@ -144,22 +253,27 @@ export const logError: LogErrorFunc = (
 ) => {
   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 (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))}`);
+      Logger.raw(`  ${Logger.infoText(tryStringify(error.data))}\n`);
   });
   //Logger.line();
   return null;
 };
 
 export const progress = {
+  current: { interrupt: (x: string) => {} },
   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,
-  }),
+  // 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,
+  // }),
 };

package/src/util/os.ts

@@ -0,0 +1,12 @@
+import os from 'os';
+
+export const winSlash = (str: string) =>
+  os.platform() === 'win32' ? str.replaceAll('/', '\\') : str;
+
+export const linuxSlash = (str: string) =>
+  os.platform() === 'win32' ? str.replaceAll('\\', '/') : str;
+
+export const normaliseLineEndings = (
+  str: string,
+  lineEnd = os.platform() === 'win32' ? '\r\n' : 'n'
+) => str.replace(/\r?\n/g, lineEnd);

package/src/util/timers.ts

@@ -0,0 +1,24 @@
+export const promiseDelay = (delay: number, value: any) => {
+  let timeout: NodeJS.Timeout | null;
+  let _reject: PromiseRejectionEvent['reason'];
+
+  const wait = () =>
+    new Promise((resolve, reject) => {
+      _reject = reject;
+      timeout = setTimeout(resolve, delay, value);
+    });
+
+  const promise = wait();
+  return {
+    promise,
+    cancel() {
+      if (timeout) {
+        clearTimeout(timeout);
+        timeout = null;
+        _reject();
+        _reject = null;
+      }
+    },
+    wait,
+  };
+};

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.10";
+export const LIB_VERSION = "1.0.0-beta.100";