contensis-cli 1.0.0-beta.71 → 1.0.0-beta.75

package/src/services/ContensisCliService.ts

@@ -5,7 +5,14 @@ import inquirer from 'inquirer';
 import to from 'await-to-js';
 import chalk from 'chalk';
 import { Component, ContentType, Project } from 'contensis-core-api';
-import { isPassword, isSharedSecret, isUuid, tryStringify, url } from '~/util';
+import {
+  isPassword,
+  isSharedSecret,
+  isUuid,
+  tryParse,
+  tryStringify,
+  url,
+} from '~/util';
 import SessionCacheProvider from '../providers/SessionCacheProvider';
 import ContensisAuthService from './ContensisAuthService';
 import CredentialProvider from '~/providers/CredentialProvider';
@@ -27,6 +34,8 @@ import { Entry, Role } from 'contensis-management-api/lib/models';
 import { csvFormatter } from '~/util/csv.formatter';
 import { xmlFormatter } from '~/util/xml.formatter';
 import { jsonFormatter } from '~/util/json.formatter';
+import { diffLogStrings } from '~/util/diff';
+import { promiseDelay } from '~/util/timers';
 import {
   printBlockVersion,
   printMigrateResult,
@@ -2009,7 +2018,8 @@ class ContensisCli {
     blockId: string,
     branch: string,
     version: string,
-    dataCenter: 'hq' | 'manchester' | 'london'
+    dataCenter: 'hq' | 'manchester' | 'london',
+    follow = false
   ) => {
     const { currentEnv, env, log, messages } = this;
     const contensis = await this.ConnectContensis();
@@ -2026,8 +2036,17 @@ class ContensisCli {
         dataCenter,
       });
 
-      if (blockLogs) {
-        this.HandleFormattingAndOutput(blockLogs, () => {
+      if (err) {
+        log.error(
+          messages.blocks.failedGetLogs(blockId, currentEnv, env.currentProject)
+        );
+        log.error(jsonFormatter(err));
+      } else if (blockLogs) {
+        const removeTrailingNewline = (logs: string) =>
+          logs.endsWith('\n') ? logs.slice(0, logs.length - 1) : logs;
+        const renderLogs = removeTrailingNewline(blockLogs);
+
+        this.HandleFormattingAndOutput(renderLogs, () => {
           // print the logs to console
           console.log(
             `  - ${blockId} ${branch} ${
@@ -2035,20 +2054,176 @@ class ContensisCli {
             } [${dataCenter}]`
           );
           log.line();
-          console.log(log.infoText(blockLogs));
-          log.line();
+          console.log(log.infoText(renderLogs));
+        });
+
+        // Code for the `--follow` options
+        let following = follow;
+        let alreadyShown = blockLogs;
+        let needsNewLine = false;
+        let counter = 0;
+
+        // remove existing listeners and add them back afterwards
+        const listeners = process.listeners('SIGINT');
+
+        process.removeAllListeners('SIGINT');
+        // add listener to update following to false and break out
+        process.on('SIGINT', () => {
+          Logger.warning(
+            `\n${messages.blocks.stopFollow(
+              blockId,
+              currentEnv,
+              env.currentProject
+            )}`
+          );
+          stopFollowing();
+        });
+
+        let delay = promiseDelay(5 * 1000, null);
+        const stopFollowing = () => {
+          following = false;
+          delay.cancel();
+
+          // Add back the listeners we removed previously
+          process.removeAllListeners('SIGINT');
+          for (const listener of listeners)
+            process.addListener('SIGINT', listener);
+        };
+
+        while (following) {
+          if (counter++ > 300) {
+            Logger.warning(
+              `\n${messages.blocks.timeoutFollow(
+                blockId,
+                currentEnv,
+                env.currentProject
+              )}`
+            );
+            stopFollowing();
+          }
+
+          // wait n. seconds then poll for logs again
+          await delay.wait();
+
+          const [lastErr, lastLogs] = following
+            ? await contensis.blocks.GetBlockLogs({
+                blockId,
+                branchId: branch,
+                version,
+                dataCenter,
+              })
+            : [null, null];
+
+          if (lastLogs) {
+            // Find the difference and output it next
+            const difference = diffLogStrings(lastLogs, alreadyShown);
+            if (difference) {
+              if (needsNewLine) {
+                console.log('');
+              }
+              // Take the trailing newline off of the logged output to
+              // avoid blank lines inbetween logs fetched sequentially
+              const render = removeTrailingNewline(difference);
+              console.log(log.infoText(render));
+
+              // Add what we've just rendered to already shown "cache"
+              alreadyShown += render;
+              needsNewLine = false;
+            } else {
+              // If no difference output a dot
+              process.stdout.write('.');
+              needsNewLine = true;
+            }
+          } else if (lastErr) {
+            // If error output an x
+            process.stdout.write('x');
+          }
+        }
+      }
+    }
+  };
+
+  PrintProxies = async (proxyId?: string) => {
+    const { currentEnv, env, log, messages } = this;
+    const contensis = await this.ConnectContensis();
+    if (contensis) {
+      // Retrieve proxies list for env
+      const [err, proxies] = await contensis.proxies.GetProxies(proxyId);
+
+      if (Array.isArray(proxies)) {
+        this.HandleFormattingAndOutput(proxies, () => {
+          // print the proxies to console
+          log.success(messages.proxies.list(currentEnv, env.currentProject));
+          for (const { id, name, description, endpoints, version } of proxies) {
+            console.log(
+              `  - ${name} [${
+                version.versionNo
+              }] ${id} ${log.infoText`${description}`}`
+            );
+            for (const [language, endpoint] of Object.entries(endpoints))
+              console.log(
+                `      - ${log.infoText`language: ${language}
+        server: ${endpoint.server}
+        headers.host: ${endpoint.headers.host}
+        ssl: ${endpoint.ssl}`}`
+              );
+          }
         });
       }
 
       if (err) {
-        log.error(
-          messages.blocks.failedGetLogs(blockId, currentEnv, env.currentProject)
-        );
+        log.error(messages.proxies.noList(currentEnv, env.currentProject));
         log.error(jsonFormatter(err));
       }
     }
   };
 
+  PrintRenderers = async (rendererId?: string) => {
+    const { currentEnv, env, log, messages } = this;
+    const contensis = await this.ConnectContensis();
+    if (contensis) {
+      // Retrieve renderers list for env
+      const [err, renderers] = await contensis.renderers.GetRenderers(
+        rendererId
+      );
+
+      if (Array.isArray(renderers)) {
+        this.HandleFormattingAndOutput(renderers, () => {
+          // print the renderers to console
+          log.success(messages.renderers.list(currentEnv, env.currentProject));
+          for (const {
+            id,
+            description,
+            assignedContentTypes,
+            rules,
+            version,
+          } of renderers) {
+            console.log(
+              `  - ${id} [${version.versionNo}] ${log.infoText`${description}`}`
+            );
+            if (assignedContentTypes?.length)
+              console.log(
+                log.infoText`      assignedContentTypes: ${assignedContentTypes.join(
+                  ', '
+                )}`
+              );
+            for (const rule of rules)
+              if (rule.return)
+                console.log(
+                  log.infoText`      ${
+                    rule.return.endpointId ? 'endpointId' : 'blockId'
+                  }: ${rule.return.endpointId || rule.return.blockId}`
+                );
+          }
+        });
+      }
+
+      if (err) {
+        log.error(messages.renderers.noList(currentEnv, env.currentProject));
+        log.error(jsonFormatter(err));
+      }
+    }
+  };
   HandleFormattingAndOutput = <T>(obj: T, logFn: (obj: T) => void) => {
     const { format, log, messages, output } = this;
     if (!format) {
@@ -2068,15 +2243,16 @@ class ContensisCli {
 
     if (output) {
       let writeString = '';
+      const isText = !tryParse(obj) && typeof obj === 'string';
       if (format === 'csv') {
         writeString = csvFormatter(obj as any);
       } else if (format === 'xml') {
         writeString = xmlFormatter(obj as any);
-      } else writeString = jsonFormatter(obj);
+      } else writeString = isText ? (obj as string) : jsonFormatter(obj);
       // write output to file
       if (writeString) {
         fs.writeFileSync(output, writeString);
-        log.success(messages.app.fileOutput(format, output));
+        log.success(messages.app.fileOutput(isText ? 'text' : format, output));
       } else {
         log.info(messages.app.noFileOutput());
       }

package/src/shell.ts

@@ -162,6 +162,8 @@ class ContensisShell {
         'list components',
         'list keys',
         'list models',
+        'list proxies',
+        'list renderers',
         'list roles',
         'list webhooks',
         'push block',

package/src/util/diff.ts

@@ -0,0 +1,21 @@
+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 > 20)
+      incomingLineIndices.push(
+        incomingLines.findIndex(
+          incomingLine => incomingLine === 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');
+};

package/src/util/index.ts

@@ -8,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) {

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