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

package/src/commands/globalOptions.ts

@@ -1,9 +1,10 @@
 import { Command, Option } from 'commander';
+import { MigrateRequest } from 'migratortron';
 import { url } from '~/util';
 
 // Map various input options into a request to be processed
 // by Migratortron / Contensis import library
-export const mapContensisOpts = (opts: any = {}) => ({
+export const mapContensisOpts = (opts: any = {}): MigrateRequest => ({
   source:
     opts.sourceAlias || opts.sourceProjectId
       ? {
@@ -14,6 +15,8 @@ export const mapContensisOpts = (opts: any = {}) => ({
         }
       : undefined,
   models: opts.modelIds,
+  copyField: opts.copyField,
+  // convert various cli options into MigrateRequest.query format
   query:
     opts.id ||
     opts.entryIds ||
@@ -23,7 +26,8 @@ export const mapContensisOpts = (opts: any = {}) => ({
     opts.paths ||
     opts.assetType ||
     opts.contentType ||
-    opts.dataFormat
+    opts.dataFormat ||
+    opts.deliveryApi
       ? {
           assetTypes: opts.assetType,
           contentTypeIds: opts.contentType,
@@ -33,11 +37,13 @@ export const mapContensisOpts = (opts: any = {}) => ({
           includePaths: opts.paths,
           orderBy: opts.orderBy,
           searchTerm: opts.phrase,
+          useDelivery: opts.deliveryApi,
         }
       : undefined,
   zenQL: opts.zenql,
   transformGuids: !opts.preserveGuids,
   ignoreErrors: opts.ignoreErrors,
+  concurrency: opts.concurrency ? Number(opts.concurrency) : undefined,
 });
 
 /* Output options */
@@ -81,6 +87,11 @@ const sharedSecret = new Option(
 );
 
 /* Entry get options */
+export const delivery = new Option(
+  '-delivery --delivery-api',
+  'use delivery api to get the entries'
+);
+
 export const zenql = new Option(
   '-q --zenql <zenql>',
   'get entries with a supplied ZenQL statement'
@@ -121,6 +132,18 @@ export const ignoreErrors = new Option(
   'commit the import ignoring any reported errors'
 ).default(false);
 
+export const outputEntries = new Option(
+  '-oe --output-entries <outputEntries>',
+  'which details of the entries included in the import to output'
+)
+  .choices(['errors', 'changes', 'all'])
+  .default('errors');
+
+export const concurrency = new Option(
+  '-conc --concurrency <concurrency>',
+  'the number of entries to load in parallel'
+).default(2);
+
 export const addConnectOptions = (program: Command) =>
   program.addOption(alias.hideHelp()).addOption(project.hideHelp());
 

package/src/commands/import.ts

@@ -2,9 +2,11 @@ import { Command, Option } from 'commander';
 import { cliCommand } from '~/services/ContensisCliService';
 import {
   commit,
+  concurrency,
   getEntryOptions,
   ignoreErrors,
   mapContensisOpts,
+  outputEntries,
 } from './globalOptions';
 
 export const makeImportCommand = () => {
@@ -113,14 +115,8 @@ Example call:
       '-preserve --preserve-guids',
       'include this flag when you are importing entries that you have previously exported and wish to update'
     )
-    .addOption(
-      new Option(
-        '-oe --output-entries <outputEntries>',
-        'which details of the entries included in the import to output'
-      )
-        .choices(['errors', 'changes', 'all'])
-        .default('errors')
-    )
+    .addOption(concurrency)
+    .addOption(outputEntries)
     .addOption(ignoreErrors)
     .addHelpText(
       'after',

package/src/commands/index.ts

@@ -2,6 +2,7 @@ import { Command } from 'commander';
 import { Logger } from '~/util/logger';
 import { LIB_VERSION } from '~/version';
 import { makeConnectCommand } from './connect';
+import { makeCopyCommand } from './copy';
 import { makeCreateCommand } from './create';
 import { makeDevCommand } from './dev';
 import { makeDiffCommand } from './diff';
@@ -49,6 +50,9 @@ const commands = () => {
   program.addCommand(
     addGlobalOptions(makeCreateCommand()).copyInheritedSettings(program)
   );
+  program.addCommand(
+    addGlobalOptions(makeCopyCommand()).copyInheritedSettings(program)
+  );
   program.addCommand(
     addConnectOptions(
       addAuthenticationOptions(makeDevCommand())
@@ -58,9 +62,9 @@ const commands = () => {
     addGlobalOptions(makeExecuteCommand()).copyInheritedSettings(program)
   );
   program.addCommand(
-    addGlobalOptions(
-      addImportOptions(makeDiffCommand())
-    ).copyInheritedSettings(program)
+    addGlobalOptions(addImportOptions(makeDiffCommand())).copyInheritedSettings(
+      program
+    )
   );
   program.addCommand(
     addGlobalOptions(makeGetCommand()).copyInheritedSettings(program)

package/src/factories/RequestHandlerFactory.ts

@@ -0,0 +1,246 @@
+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, checkDir, 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;
+  version; // pass in a specific release version to run
+
+  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(version?: string, prerelease = false) {
+    this.prerelease = prerelease;
+    this.version = version;
+  }
+
+  // Use the factory to create a request handler instance
+  // handling the download and updating of the external binary
+  async Create() {
+    const { moduleInfo, version } = this;
+    const downloadImmediately =
+      !moduleInfo?.version || moduleInfo?.version === '*' || this.version;
+
+    if (downloadImmediately) {
+      // Create cli-manifest.json
+      this.manifest.writeModule(this.name, this.moduleInfo);
+
+      // Download for first time use (await)
+      await this.CheckUpdate({ verbose: true, version });
+    }
+
+    // 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 (!downloadImmediately) 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,
+    version,
+  }: { verbose?: boolean; version?: string } = {}) {
+    const { cmd, debug, log, manifest, messages, moduleInfo } = this;
+
+    const github = new GitHubCliModuleProvider(moduleInfo.github);
+
+    // Find latest version
+    const release = await github.FindLatestRelease(version);
+
+    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));
+
+    const downloadSpecificRelease =
+      version && !checkDir('c') && release?.tag_name;
+
+    // Should we download an update?
+    if (
+      (release?.tag_name &&
+        ![moduleInfo.version, moduleInfo.install].includes(release.tag_name)) ||
+      downloadSpecificRelease
+    ) {
+      // 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, {
+          cmd,
+          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
+            ),
+          });
+
+        if (!version) {
+          // 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);
+        } else {
+          // Set module version in memory so the request handler
+          // will be invoked with this version this time only
+          this.moduleInfo.version = release.tag_name;
+        }
+      }
+    }
+  }
+
+  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 = (version?: string) =>
+  new RequestHandlerFactory(version).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,30 @@ 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 ${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`,
+    overrideBlock: () => `Which block will you be running?`,
+    overrideUri: () => `How to access your development site`,
+    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,200 @@
+import { ContensisMigrationService } from 'migratortron';
+import PQueue from 'p-queue';
+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;
+  iisHostname: string;
+  podClusterId: string;
+  accessToken: string; // needed?
+  clientId: string;
+  sharedSecret: string;
+  blocks: BlockJson[];
+  renderers: RendererJson[];
+}
+
+class RequestHandlerArgs {
+  private cli;
+  args?: string[];
+  siteConfig?: ISiteConfigYaml;
+
+  constructor(cli: ContensisCli) {
+    this.cli = cli;
+  }
+
+  Create = async () => {
+    this.siteConfig = await this.buildSiteConfig();
+    await this.cli.Login(this.cli.env.lastUserId, { silent: true }); // to hydrate the auth service
+    this.args = this.getArgs();
+  };
+
+  buildSiteConfig = async () => {
+    const { currentEnv, currentProject, env, log, messages, urls } = this.cli;
+    const contensis = await this.cli.ConnectContensis();
+
+    const siteConfig: ISiteConfigYaml = {
+      alias: currentEnv,
+      projectId: currentProject,
+      iisHostname: urls?.iisPreviewWeb.split('//')[1] || '',
+      podClusterId: 'hq',
+      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[] = [];
+      const queue = new PQueue({ concurrency: 4 });
+      for (const block of blocksRaw || []) {
+        queue.add(async () => {
+          // 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,
+            });
+          }
+        });
+      }
+
+      await queue.onIdle();
+      return blocks;
+    };
+
+    if (contensis) {
+      const [blocks, renderers] = await Promise.all([
+        getBlocks(contensis),
+        contensis.renderers.GetRenderers(),
+      ]);
+
+      siteConfig.blocks = blocks;
+      siteConfig.renderers = renderers?.[1]
+        ?.filter(r => blocks.find(b => b.id === r.id))
+        .map(r => ({
+          id: r.id,
+          name: r.name,
+          assignedContentTypes: r.assignedContentTypes,
+          rules: r.rules,
+        }));
+    }
+    return siteConfig;
+  };
+
+  getArgs = (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 { cli, siteConfig } = this;
+    if (siteConfig) {
+      // 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 === '--iis-hostname'))
+        args.push('--iis-hostname', siteConfig.iisHostname);
+      if (!args.find(a => a === '--pod-cluster-id'))
+        args.push('--pod-cluster-id', siteConfig.podClusterId);
+      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));
+    }
+
+    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;
+  };
+
+  overrideBlock = (blockId: string, overrideUri: string) => {
+    if (blockId && blockId !== 'none') {
+      const blockIndex = this.siteConfig?.blocks.findIndex(
+        b => b.id.toLowerCase() === blockId.toLowerCase()
+      );
+      if (
+        typeof blockIndex === 'number' &&
+        !isNaN(blockIndex) &&
+        this.siteConfig?.blocks[blockIndex]
+      ) {
+        this.siteConfig.blocks[blockIndex].baseUri = overrideUri;
+        // this.siteConfig.blocks[blockIndex].staticPaths.push(
+        //   ...['/static/*', '/image-library/*']
+        // );
+        this.siteConfig.blocks[blockIndex].staticPaths.push('/*.js');
+      }
+    }
+  };
+}
+
+export default RequestHandlerArgs;