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

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,7 @@
+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;

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