contensis-cli 1.1.1 → 1.1.2-beta.1

package/src/factories/RequestHandlerFactory.ts

@@ -0,0 +1,225 @@
+import { spawn } from 'child_process';
+import inquirer from 'inquirer';
+import { createSpinner } from 'nanospinner';
+import path from 'path';
+import { LogMessages } from '~/localisation/en-GB';
+import GitHubCliModuleProvider from '~/providers/GitHubCliModuleProvider';
+
+import ManifestProvider from '~/providers/ManifestProvider';
+import { appRootDir, joinPath } from '~/providers/file-provider';
+import { isDebug } from '~/util/debug';
+import { Logger } from '~/util/logger';
+
+export class RequestHandlerFactory {
+  debug = isDebug();
+  log = Logger;
+  messages = LogMessages;
+  manifest = new ManifestProvider(); // Load cli-manifest.json
+
+  basePath = path.join(appRootDir);
+  name = 'request-handler-localdevelopment';
+  cmd = 'Zengenti.Contensis.RequestHandler.LocalDevelopment';
+
+  prerelease;
+
+  get exePath() {
+    return path.join(this.basePath, `${this.name}-${this.moduleInfo.version}`);
+  }
+
+  get moduleInfo() {
+    return (
+      this.manifest.getModule(this.name) || {
+        github: 'contensis/request-handler-localdevelopment',
+        version: '*',
+      }
+    );
+  }
+
+  constructor(prerelease = false) {
+    this.prerelease = prerelease;
+  }
+
+  // Use the factory to create a request handler instance
+  // handling the download and updating of the external binary
+  async Create() {
+    const { moduleInfo } = this;
+    const firstUse = !moduleInfo?.version || moduleInfo?.version === '*';
+
+    if (firstUse) {
+      // Create cli-manifest.json
+      this.manifest.writeModule(this.name, this.moduleInfo);
+
+      // Download for first time use (await)
+      await this.CheckUpdate({ verbose: true });
+    }
+
+    // Apply any downloaded/pending update so we launch that version
+    await this.ApplyUpdate();
+
+    // Fire an async update check and continue working in the background (do not await)
+    if (!firstUse) this.CheckUpdate();
+
+    // Return a RequestHandler ready to invoke
+    return this.CreateInvoke(this);
+  }
+
+  CreateInvoke(self = this) {
+    // Hoist the vars we need from `this` as we lose scope
+    // when the function is returned from the Create() method
+    const { debug, log, messages, cmd, exePath } = self;
+
+    // Invoke request handler method
+    return async (args: string[]) => {
+      const child = spawn(joinPath(exePath, cmd), args, { stdio: 'inherit' });
+
+      if (args?.length && debug)
+        log.warning(
+          `Spawning process with supplied args: ${JSON.stringify(
+            child.spawnargs,
+            null,
+            2
+          )}`
+        );
+
+      let isRunning = false;
+
+      // Log child output through event listeners
+      child?.stdout?.on('data', data => {
+        isRunning = true;
+        log.raw(data);
+      });
+
+      child?.stderr?.on('data', data => {
+        log.error(data);
+      });
+
+      child.on('spawn', () => {
+        isRunning = true;
+        log.help(messages.devrequests.spawn());
+      });
+
+      child.on('exit', code => {
+        isRunning = false;
+
+        log[code === 0 ? 'success' : 'warning'](
+          messages.devrequests.exited(code)
+        );
+      });
+
+      child.on('error', error => {
+        isRunning = false;
+        log.error(messages.devrequests.errored(error));
+      });
+
+      await new Promise(resolve => setTimeout(resolve, 2000));
+
+      // keep the method running until we can return
+      while (true === true) {
+        if (!isRunning) return;
+        await new Promise(resolve => setTimeout(resolve, 1000));
+      }
+    };
+  }
+
+  async CheckUpdate({ verbose = false }: { verbose?: boolean } = {}) {
+    const { debug, log, manifest, messages, moduleInfo } = this;
+    const github = new GitHubCliModuleProvider(moduleInfo.github);
+    // Find latest version
+    const release = await github.FindLatestRelease();
+    if (verbose || debug)
+      if (release)
+        log.info(
+          `${messages.devrequests.install.download(
+            moduleInfo.github,
+            release.tag_name
+          )}\n${release.html_url}`
+        );
+      else
+        log.warning(messages.devrequests.install.notFound(moduleInfo.github));
+
+    // Should we download an update?
+    if (
+      release?.tag_name &&
+      ![moduleInfo.version, moduleInfo.install].includes(release.tag_name)
+    ) {
+      // Download platform-specific release asset
+      const downloadPath = path.join(
+        this.basePath,
+        `${this.name}-${release.tag_name}`
+      );
+
+      // add spinner while downloading
+      const spinner = createSpinner(
+        messages.devrequests.install.downloading(
+          moduleInfo.github,
+          release.tag_name
+        )
+      );
+      if (verbose || debug) {
+        spinner.start();
+      }
+      try {
+        await github.DownloadRelease(release, {
+          path: downloadPath,
+          // Map NodeJS os platform to release asset name
+          platforms: [
+            ['win32', 'win-x64'],
+            ['darwin', 'osx-x64'],
+            ['linux', 'linux-x64'],
+          ],
+        });
+      } catch (ex: any) {
+        spinner.error();
+        log.error(
+          messages.devrequests.install.downloadFail(
+            moduleInfo.github,
+            release.tag_name
+          ),
+          ex
+        );
+      } finally {
+        if (verbose || debug)
+          spinner.success({
+            text: messages.devrequests.install.downloaded(
+              moduleInfo.github,
+              release.tag_name
+            ),
+          });
+
+        // Update module info with downloaded release
+        this.moduleInfo.install = release.tag_name;
+        // Write module info update to manifest so it installs on next invoke
+        manifest.writeModule(this.name, this.moduleInfo);
+      }
+    }
+  }
+
+  async ApplyUpdate() {
+    const { manifest, messages, moduleInfo } = this;
+
+    if (moduleInfo.install && moduleInfo.version !== moduleInfo.install) {
+      let { apply } =
+        moduleInfo.version === '*'
+          ? { apply: true }
+          : await inquirer.prompt({
+              name: 'apply',
+              type: 'confirm',
+              message: messages.devrequests.install.applyUpdate(
+                moduleInfo.install,
+                moduleInfo.version
+              ),
+              default: 'Y',
+            });
+
+      if (apply) {
+        moduleInfo.version = moduleInfo.install;
+        delete moduleInfo.install;
+        manifest.writeModule(this.name, this.moduleInfo);
+
+        // TODO: clean up user folder by deleting old version(s)}
+      }
+    }
+  }
+}
+
+export const createRequestHandler = () => new RequestHandlerFactory().Create();

package/src/localisation/en-GB.ts

@@ -341,10 +341,36 @@ export const LogMessages = {
           return Logger.infoText(status);
       }
     },
-    get: (id: string, env: string, projectId?: string) =>
-      `[${env}] Block ${id} in project ${projectId}:`,
+    get: (
+      id: string,
+      branch: string,
+      version: string,
+      env: string,
+      projectId?: string
+    ) =>
+      `[${env}] ${
+        version && version !== 'latest'
+          ? `Found v${version}`
+          : 'Latest block versions'
+      } for ${Logger.infoText(`${branch}/`)}${Logger.highlightText(
+        id
+      )} in project ${projectId}\n`,
+    noGet: (
+      id: string,
+      branch: string,
+      version: string,
+      env: string,
+      projectId?: string
+    ) =>
+      `[${env}] Did not find ${
+        version ? `v${version}` : 'any block versions'
+      } for ${Logger.highlightText(id)} in branch ${Logger.infoText(
+        branch
+      )} in ${Logger.infoText(projectId)} project`,
+    noGetTip: () =>
+      `Check the available blocks and branches in this project by running "list blocks"`,
     list: (env: string, projectId?: string) =>
-      `[${env}] Blocks in project ${projectId}:`,
+      `[${env}] Blocks in project ${projectId}\n`,
     noList: (env: string, projectId?: string) =>
       `[${env}] Cannot retrieve blocks in project ${projectId}`,
     getLogs: (id: string, branch: string, env: string, projectId?: string) =>
@@ -367,15 +393,6 @@ export const LogMessages = {
       `[${env}] Unable to push block ${Logger.highlightText(
         id
       )} in project ${projectId}`,
-    latestVersion: (
-      version: string,
-      id: string,
-      env: string,
-      projectId?: string
-    ) =>
-      `[${env}] Found latest block version ${Logger.highlightText(
-        id
-      )} in project ${projectId} ${Logger.highlightText(version)}`,
     failedParsingVersion: () =>
       `Did not find a "version.versionNo" in response`,
     actionComplete: (
@@ -586,4 +603,29 @@ export const LogMessages = {
         'my-awesome-website'
       )}`,
   },
+  devrequests: {
+    install: {
+      notFound: (repo: string) =>
+        `Could not find a release in ${repo} repo - please check github`,
+      download: (repo: string, version: string) =>
+        `Found release ${repo} ${version}`,
+      downloading: (repo: string, version: string) =>
+        `Downloading ${repo} ${version}`,
+      downloadFail: (repo: string, version: string) =>
+        `Problem downloading release ${version} from ${repo}`,
+      downloaded: (repo: string, version: string) =>
+        `Downloaded ${repo} ${version}`,
+      applyUpdate: (version: string, existing: string) =>
+        `Use updated version ${version} ${Logger.infoText(
+          `(replaces ${existing})`
+        )}?`,
+    },
+    launch: () => `Launching request handler for local development`,
+    spawn: () =>
+      `If you see a firewall popup requesting network access, it is safe to approve`,
+    exited: (code: number | null) =>
+      `Request handler exited with code ${code}\n`,
+    errored: (error: Error) =>
+      `Could not launch request handler due to error \n${error}`,
+  },
 };

package/src/mappers/DevRequests-to-RequestHanderCliArgs.ts

@@ -0,0 +1,145 @@
+import { ContensisMigrationService } from 'migratortron';
+import ContensisCli from '~/services/ContensisCliService';
+
+type EndpointJson = {
+  id: string;
+  path: string;
+};
+
+type BlockJson = {
+  id: string;
+  baseUri: string;
+  staticPaths: string[];
+  endpoints: EndpointJson[];
+  versionNo: number;
+  branch: string;
+};
+
+type RendererJson = {
+  id: string;
+  name: string;
+  rules: RendererRuleJson[];
+  assignedContentTypes: string[];
+};
+
+type RendererRuleJson = {
+  return?: {
+    blockId?: string;
+    endpointId?: string | null;
+    version?: string;
+  };
+};
+interface ISiteConfigYaml {
+  alias: string;
+  projectId: string;
+  accessToken: string;
+  clientId: string;
+  sharedSecret: string;
+  blocks: BlockJson[];
+  renderers: RendererJson[];
+}
+
+export const buildSiteConfig = async (cli: ContensisCli) => {
+  const { currentEnv, env, log, messages } = cli;
+  const siteConfig: ISiteConfigYaml = {
+    alias: cli.currentEnv,
+    projectId: cli.currentProject,
+    accessToken: '',
+    clientId: '',
+    sharedSecret: '',
+    blocks: [],
+    renderers: [],
+  };
+
+  const getBlocks = async (contensis: ContensisMigrationService) => {
+    const [err, blocksRaw] = await contensis.blocks.GetBlocks();
+    if (err) log.error(messages.blocks.noList(currentEnv, env.currentProject));
+
+    // const blocksRaw = await cli.PrintBlocks();
+
+    const blocks: BlockJson[] = [];
+    for (const block of blocksRaw || []) {
+      // Retrieve block version
+      const [err, versions] = await contensis.blocks.GetBlockVersions(
+        block.id,
+        'default',
+        'latest'
+      );
+      if (err || versions?.length === 0)
+        log.warning(
+          messages.blocks.noGet(
+            block.id,
+            'default',
+            'latest',
+            currentEnv,
+            env.currentProject
+          )
+        );
+      if (versions?.[0]) {
+        const v = versions[0];
+        blocks.push({
+          id: v.id,
+          baseUri: v.previewUrl,
+          staticPaths: v.staticPaths,
+          endpoints: v.endpoints,
+          versionNo: v.version.versionNo,
+          branch: v.source.branch,
+        });
+      }
+    }
+    return blocks;
+  };
+
+  const contensis = await cli.ConnectContensis();
+  if (contensis) {
+    const [blocks, renderers] = await Promise.all([
+      getBlocks(contensis),
+      contensis.renderers.GetRenderers(),
+    ]);
+
+    siteConfig.blocks = blocks;
+    siteConfig.renderers = renderers?.[1]?.map(r => ({
+      id: r.id,
+      name: r.name,
+      assignedContentTypes: r.assignedContentTypes,
+      rules: r.rules,
+    }));
+  }
+  return siteConfig;
+};
+
+export const requestHandlerCliArgs = async (
+  cli: ContensisCli,
+  overrideArgs: string[] = []
+) => {
+  const args = overrideArgs
+    ? typeof overrideArgs?.[0] === 'string' && overrideArgs[0].includes(' ', 2)
+      ? overrideArgs[0].split(' ')
+      : overrideArgs
+    : []; // args could be [ '-c .\\site_config.yaml' ] or [ '-c', '.\\site_config.yaml' ]
+
+  const siteConfig = await buildSiteConfig(cli);
+  // Add required args
+  if (!args.find(a => a === '--alias')) args.push('--alias', cli.currentEnv);
+  if (!args.find(a => a === '--project-api-id'))
+    args.push('--project-api-id', cli.currentProject);
+  if (!args.find(a => a === '--blocks-json'))
+    args.push('--blocks-json', JSON.stringify(siteConfig.blocks));
+  if (!args.find(a => a === '--renderers-json'))
+    args.push('--renderers-json', JSON.stringify(siteConfig.renderers));
+
+  await cli.Login(cli.env.lastUserId, { silent: true }); // to hydrate the auth service
+  const client = cli.auth?.clientDetails;
+  if (client) {
+    if (!args.find(a => a === '--client-id') && 'clientId' in client)
+      args.push('--client-id', client.clientId);
+    if (!args.find(a => a === '--client-secret') && 'clientSecret' in client)
+      args.push('--client-secret', client.clientSecret);
+    if (!args.find(a => a === '--username') && 'username' in client)
+      args.push('--username', client.username);
+    if (!args.find(a => a === '--password') && 'password' in client)
+      args.push('--password', client.password);
+  }
+
+  return args;
+};

package/src/providers/GitHubCliModuleProvider.ts

@@ -0,0 +1,114 @@
+import os from 'os';
+import Zip from 'adm-zip';
+import type { Endpoints } from '@octokit/types';
+import HttpProvider from '~/providers/HttpProvider';
+import {
+  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() {
+    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 (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,
+    {
+      path,
+      platforms,
+      unzip = true,
+    }: { 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);
+      }
+    } 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,8 @@ export const appPath = (filePath: string) =>
 export const cwdPath = (filePath: string) =>
   path.isAbsolute(filePath) ? filePath : path.join(process.cwd(), filePath);
 
+export const joinPath = path.join;
+
 type DetectedFileType =
   | { type: 'json'; contents: any }
   | { type: 'xml' | 'csv'; contents: string };