contensis-cli 1.0.0-beta.8 → 1.0.0-beta.80

package/src/util/logger.ts

@@ -2,12 +2,13 @@
 import chalk from 'chalk';
 import dateFormat from 'dateformat';
 import deepCleaner from 'deep-cleaner';
-import ProgressBar from 'progress';
-import { tryStringify } from '.';
+// 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 +37,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${
+              isSysError(err) ? err.toString() : JSON.stringify(err, null, 2)
+            }`
+          : ''
       }`
-    )}\n`;
+    )}${newline}`;
     if (progress.active) progress.current.interrupt(message);
     else console.log(message);
   };
@@ -83,7 +88,7 @@ export class Logger {
     else console.log(message);
     progress.current.interrupt(message);
   };
-  static json: LogJsonMethod = (content, depth = 9) =>
+  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 +96,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 +150,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++;
       }
     }
   };
@@ -144,22 +223,23 @@ 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 ('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/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/version.ts

@@ -1 +1 @@
-export const LIB_VERSION = "1.0.0-beta.8";
+export const LIB_VERSION = "1.0.0-beta.80";