contensis-cli 1.1.2-beta.0 → 1.1.2-beta.10

package/src/providers/GitHubCliModuleProvider.ts

@@ -0,0 +1,127 @@
+import os from 'os';
+import Zip from 'adm-zip';
+import type { Endpoints } from '@octokit/types';
+import HttpProvider from '~/providers/HttpProvider';
+import {
+  addExecutePermission,
+  checkDir,
+  joinPath,
+  removeDirectory,
+  removeFile,
+} from './file-provider';
+import { doRetry } from '~/util/fetch';
+
+type GitHubApiRelease =
+  Endpoints['GET /repos/{owner}/{repo}/releases/latest']['response']['data'];
+
+class GitHubCliModuleProvider {
+  http: HttpProvider;
+  repo: string;
+  baseUrl = 'https://api.github.com/repos';
+
+  get releases_url() {
+    return `${this.baseUrl}/${this.repo}/releases`;
+  }
+  get latest_release_url() {
+    return `${this.baseUrl}/${this.repo}/releases/latest`;
+  }
+
+  download?: {
+    tag: string;
+    name: string;
+    url: string;
+    browser_url: string;
+  };
+
+  constructor(repo: string) {
+    this.http = new HttpProvider();
+    this.repo = repo;
+  }
+
+  async FindLatestRelease(version?: string) {
+    const { http, latest_release_url, releases_url } = this;
+    // return latest tag version is:
+
+    const responses = await Promise.all([
+      http.get<GitHubApiRelease>(latest_release_url, {
+        doRetry: doRetry({ silent: true }),
+      }),
+      http.get<GitHubApiRelease[]>(releases_url),
+    ]);
+
+    const [latestErr, latest, latestResponse] = responses[0];
+    const [releasesErr, releases] = responses[1];
+
+    if (releasesErr) {
+      throw new Error(`Unable to get releases`, { cause: releasesErr });
+    } else if (!releases || releases.length === 0)
+      throw new Error(`No releases available`);
+    else if (version) {
+      const release = releases.find(
+        r => r.tag_name.toLowerCase() === version.toLowerCase()
+      );
+      if (release) return release;
+      else throw new Error(`No release for ${version} found`);
+    } else if (latestErr && !latest) {
+      if (latestResponse?.status === 404 && releases?.length) {
+        // No latest release, check releases for prerelease version, fallback to last release
+        const release = releases.find(r => r.prerelease) || releases[0];
+
+        if (release) return release;
+      }
+    } else {
+      return latest;
+    }
+  }
+
+  async DownloadRelease(
+    release: GitHubApiRelease,
+    {
+      cmd,
+      path,
+      platforms,
+      unzip = true,
+    }: {
+      cmd: string;
+      path: string;
+      unzip?: boolean;
+      platforms: [NodeJS.Platform, string][];
+    }
+  ) {
+    // find os-specific asset
+    const platform = platforms.find(p => p[0] === os.platform()) || [
+      os.platform(),
+      os.platform(),
+    ];
+
+    const asset = release.assets.find(r =>
+      r.name.toLowerCase().includes(platform[1])
+    );
+
+    // download asset
+    if (asset) {
+      const filePath = joinPath(path, asset.name);
+      removeDirectory(path);
+      checkDir(filePath);
+      await this.http.downloadFile(asset.browser_download_url, filePath);
+
+      if (unzip && asset.name.endsWith('.zip')) {
+        // unzip the downloaded file
+        const zipFile = new Zip(filePath);
+        zipFile.extractAllTo(path);
+
+        // delete the downloaded zip file
+        removeFile(filePath);
+      }
+
+      if (os.platform() !== 'win32') addExecutePermission(joinPath(path, cmd));
+    } else
+      throw new Error(
+        `no asset found in release ${
+          release.tag_name
+        } for platform ${os.platform()}\n${release.html_url}`
+      );
+  }
+}
+
+export default GitHubCliModuleProvider;

package/src/providers/HttpProvider.ts

@@ -0,0 +1,50 @@
+import to from 'await-to-js';
+import { FetchInit } from 'enterprise-fetch';
+import fs from 'fs';
+import { Readable } from 'stream';
+import { finished } from 'stream/promises';
+
+import { isJson, tryParse } from '~/util';
+import { enhancedFetch } from '~/util/fetch';
+class HttpProvider {
+  constructor() {}
+
+  async get<T = any>(url: string, init: FetchInit = {}) {
+    return this.fetch<T>(url, { method: 'GET', ...init });
+  }
+
+  async fetch<T = any>(
+    uri: string,
+    init: FetchInit = {}
+  ): Promise<[Error | null, T | undefined, Response | undefined]> {
+    const [error, response] = await to(enhancedFetch(uri, init));
+
+    if (response && !error) {
+      const [bodyError, text] = await to(response.text());
+      if (bodyError) return [bodyError, undefined, response];
+      if (isJson(text)) {
+        const err =
+          !response.status || !response.ok ? tryParse(text) : undefined;
+        const payload =
+          response.status && response.ok ? tryParse(text) : undefined;
+        return [err, payload, response];
+      }
+      return [
+        response.ok ? null : new Error(text),
+        response.ok ? (text as unknown as T) : undefined,
+        response,
+      ];
+    }
+    return [error, undefined, response];
+  }
+
+  async downloadFile(url: string, destination: string) {
+    const res = await fetch(url);
+    if (res.ok && res.body !== null) {
+      const fileStream = fs.createWriteStream(destination, { flags: 'wx' });
+      await finished(Readable.fromWeb(res.body as any).pipe(fileStream));
+    }
+  }
+}
+
+export default HttpProvider;

package/src/providers/ManifestProvider.ts

@@ -0,0 +1,43 @@
+import { tryParse } from '~/util';
+import { appPath, readFile, writeFile } from './file-provider';
+
+export type CliModule = {
+  github: string;
+  version: string;
+  install?: string;
+  cmd?: string;
+};
+
+type CliManifest = {
+  [moduleName: string]: CliModule;
+};
+
+const MANIFEST_PATH = appPath('cli-manifest.json');
+
+class ManifestProvider {
+  private manifest: CliManifest;
+
+  constructor() {
+    const manifest = tryParse(readFile(MANIFEST_PATH));
+    this.manifest = manifest || {};
+  }
+
+  get() {
+    return this.manifest;
+  }
+
+  getModule(name: string) {
+    return this.manifest?.[name];
+  }
+  writeModule(name: string, moduleInfo: CliModule) {
+    if (this.manifest) this.manifest[name] = moduleInfo;
+    else
+      this.manifest = {
+        [name]: moduleInfo,
+      };
+
+    writeFile(MANIFEST_PATH, JSON.stringify(this.manifest, null, 2));
+  }
+}
+
+export default ManifestProvider;

package/src/providers/file-provider.ts

@@ -50,6 +50,13 @@ export const removeFile = (filePath: string) => {
   }
 };
 
+export const removeDirectory = (filePath: string) => {
+  const directoryPath = appPath(filePath);
+  if (fs.existsSync(directoryPath)) {
+    fs.rmSync(directoryPath, { force: true, recursive: true });
+  }
+};
+
 export const moveFile = (file: string, fromPath: string, toPath: string) => {
   const from = path.join(appRootDir, `${fromPath}${file}`);
   const to = path.join(appRootDir, `${toPath}${file}`);
@@ -84,6 +91,12 @@ export const appPath = (filePath: string) =>
 export const cwdPath = (filePath: string) =>
   path.isAbsolute(filePath) ? filePath : path.join(process.cwd(), filePath);
 
+export const joinPath = path.join;
+
+export const addExecutePermission = (filePath: string) =>
+  // Fails in windows with `TypeError [ERR_INVALID_ARG_TYPE]: The "mode" argument must be of type number. Received undefined`
+  fs.chmodSync(filePath, fs.constants.S_IRWXU);
+
 type DetectedFileType =
   | { type: 'json'; contents: any }
   | { type: 'xml' | 'csv'; contents: string };

package/src/services/ContensisAuthService.ts

@@ -3,6 +3,17 @@ import { ClientGrants, ClientGrantType } from 'contensis-core-api';
 
 class ContensisAuthService {
   private client: NodejsClient;
+  private credentials: {
+    clientType: ClientGrantType;
+    clientDetails: ClientGrants;
+  };
+
+  get clientType() {
+    return this.credentials.clientType;
+  }
+  get clientDetails() {
+    return this.credentials.clientDetails;
+  }
 
   constructor({
     clientId = '',
@@ -21,39 +32,37 @@ class ContensisAuthService {
     projectId: string;
     rootUrl: string;
   }) {
-    let credentials: {
-      clientType: ClientGrantType;
-      clientDetails: ClientGrants;
-    };
-    if (clientId && clientSecret) {
-      credentials = {
+    if (clientId && clientSecret)
+      this.credentials = {
         clientType: 'client_credentials',
         clientDetails: {
           clientId,
           clientSecret,
         },
       };
-    } else if (username && password) {
-      credentials = {
+    else if (username && password)
+      this.credentials = {
         clientType: 'contensis_classic',
         clientDetails: {
           username,
           password,
         },
       };
-    } else if (refreshToken) {
-      credentials = {
+    else if (refreshToken)
+      this.credentials = {
         clientType: 'contensis_classic_refresh_token',
         clientDetails: {
           refreshToken,
         },
       };
-    } else {
-      credentials = { clientType: 'none', clientDetails: { refreshToken: '' } };
-    }
+    else
+      this.credentials = {
+        clientType: 'none',
+        clientDetails: { refreshToken: '' },
+      };
 
     this.client = NodejsClient.create({
-      ...credentials,
+      ...this.credentials,
       projectId,
       rootUrl,
     });

package/src/services/ContensisCliService.ts

@@ -36,6 +36,7 @@ import {
   tryStringify,
   url,
 } from '~/util';
+import { sanitiseIds } from '~/util/api-ids';
 import {
   printBlockVersion,
   printEntriesMigrateResult,
@@ -45,12 +46,13 @@ import {
   printNodesMigrateResult,
 } from '~/util/console.printer';
 import { csvFormatter } from '~/util/csv.formatter';
-import { xmlFormatter } from '~/util/xml.formatter';
 import { jsonFormatter, limitFields } from '~/util/json.formatter';
+import { xmlFormatter } from '~/util/xml.formatter';
+import { isDebug } from '~/util/debug';
 import { diffLogStrings } from '~/util/diff';
+import { findByIdOrName } from '~/util/find';
 import { logError, Logger } from '~/util/logger';
 import { promiseDelay } from '~/util/timers';
-import { findByIdOrName } from '~/util/find';
 
 let insecurePasswordWarningShown = false;
 
@@ -72,6 +74,7 @@ class ContensisCli {
   contensis?: ContensisMigrationService;
   contensisOpts: Partial<MigrateRequest>;
   currentProject: string;
+  debug = isDebug();
 
   sourceAlias?: string;
   targetEnv?: string;
@@ -140,6 +143,14 @@ class ContensisCli {
     this.session = new SessionCacheProvider();
 
     this.contensisOpts = contensisOpts;
+
+    // Explicitly sanitise supplied fields to api-friendly ids
+    if (Array.isArray(this.contensisOpts.query?.fields)) {
+      this.contensisOpts.query.fields = sanitiseIds(
+        this.contensisOpts.query.fields
+      );
+    }
+
     this.format = outputOpts?.format;
     this.output =
       outputOpts?.output && path.join(process.cwd(), outputOpts.output);
@@ -1786,6 +1797,79 @@ class ContensisCli {
     }
   };
 
+  CopyEntryField = async ({
+    commit,
+    fromFile,
+    logOutput,
+  }: {
+    commit: boolean;
+    fromFile: string;
+    logOutput: string;
+  }) => {
+    const { currentEnv, currentProject, log, messages } = this;
+
+    const contensis = await this.ConnectContensisImport({
+      commit,
+      fromFile,
+      importDataType: 'entries',
+    });
+
+    if (contensis) {
+      log.line();
+      if (contensis.isPreview) {
+        console.log(log.successText(` -- IMPORT PREVIEW -- `));
+      } else {
+        console.log(log.warningText(` *** COMMITTING IMPORT *** `));
+      }
+
+      const [err, result] = await to(
+        contensis.content.copy.MigrateFieldContent()
+      );
+
+      if (err) logError(err);
+      if (result)
+        await this.HandleFormattingAndOutput(result, () => {
+          // print the migrateResult to console
+          printEntriesMigrateResult(this, result, {
+            showAll: logOutput === 'all',
+            showDiff: logOutput === 'all' || logOutput === 'changes',
+            showChanged: logOutput === 'changes',
+          });
+        });
+
+      if (
+        result &&
+        !err &&
+        !result.errors?.length &&
+        ((!commit && result.entriesToMigrate[currentProject].totalCount) ||
+          (commit &&
+            (result.migrateResult?.created || result.migrateResult?.updated)))
+      ) {
+        log.success(
+          messages.entries.imported(
+            currentEnv,
+            commit,
+            commit
+              ? (result.migrateResult?.created || 0) +
+                  (result.migrateResult?.updated || 0)
+              : result.entriesToMigrate[currentProject].totalCount
+          )
+        );
+        if (!commit) {
+          log.raw(``);
+          log.help(messages.entries.commitTip());
+        }
+      } else {
+        log.error(messages.entries.failedImport(currentEnv), err);
+        if (!result?.entriesToMigrate?.[currentProject]?.totalCount)
+          log.help(messages.entries.notFound(currentEnv));
+      }
+    } else {
+      log.warning(messages.models.noList(currentProject));
+      log.help(messages.connect.tip());
+    }
+  };
+
   GetNodes = async (rootPath: string, depth = 0) => {
     const { currentProject, log, messages } = this;
     const contensis = await this.ConnectContensis();
@@ -2048,7 +2132,7 @@ class ContensisCli {
       // Retrieve blocks list for env
       const [err, blocks] = await contensis.blocks.GetBlocks();
 
-      if (Array.isArray(blocks)) {
+      if (Array.isArray(blocks) && blocks.length) {
         await this.HandleFormattingAndOutput(blocks, () => {
           // print the blocks to console
           log.success(messages.blocks.list(currentEnv, env.currentProject));
@@ -2082,8 +2166,8 @@ class ContensisCli {
       }
 
       if (err) {
-        log.error(messages.blocks.noList(currentEnv));
-        log.error(jsonFormatter(err));
+        log.error(messages.blocks.noList(currentEnv, env.currentProject));
+        // log.error(jsonFormatter(err));
       }
     }
   };
@@ -2103,11 +2187,29 @@ class ContensisCli {
         version
       );
 
-      if (blocks) {
+      if (err || blocks?.length === 0) {
+        log.warning(
+          messages.blocks.noGet(
+            blockId,
+            branch,
+            version,
+            currentEnv,
+            env.currentProject
+          )
+        );
+        log.help(messages.blocks.noGetTip());
+        // if (err) log.error(jsonFormatter(err));
+      } else if (blocks) {
         await this.HandleFormattingAndOutput(blocks, () => {
           // print the version detail to console
           log.success(
-            messages.blocks.get(blockId, currentEnv, env.currentProject)
+            messages.blocks.get(
+              blockId,
+              branch,
+              version,
+              currentEnv,
+              env.currentProject
+            )
           );
           for (const block of blocks)
             printBlockVersion(
@@ -2126,11 +2228,6 @@ class ContensisCli {
 
         return blocks;
       }
-
-      if (err) {
-        log.error(messages.blocks.noList(currentEnv, env.currentProject));
-        log.error(jsonFormatter(err));
-      }
     }
   };
 
@@ -2454,9 +2551,7 @@ class ContensisCli {
     const contensis = await this.ConnectContensis();
     if (contensis) {
       // Retrieve renderers list for env
-      const [err, renderers] = await (contensis.renderers.GetRenderers as any)(
-        rendererId
-      ); // TODO: resolve any cast
+      const [err, renderers] = await contensis.renderers.GetRenderers();
 
       if (Array.isArray(renderers)) {
         await this.HandleFormattingAndOutput(renderers, () => {
@@ -2487,6 +2582,7 @@ class ContensisCli {
                 );
           }
         });
+        return renderers;
       }
 
       if (err) {
@@ -2495,6 +2591,7 @@ class ContensisCli {
       }
     }
   };
+
   HandleFormattingAndOutput = async <T>(obj: T, logFn: (obj: T) => void) => {
     const { format, log, messages, output } = this;
     const fields = this.contensis?.payload.query?.fields;