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

package/src/commands/copy.ts

@@ -0,0 +1,79 @@
+import { Command } from 'commander';
+import { CopyField } from 'migratortron';
+import { cliCommand } from '~/services/ContensisCliService';
+import {
+  commit,
+  concurrency,
+  delivery,
+  entryId,
+  ignoreErrors,
+  mapContensisOpts,
+  outputEntries,
+  zenql,
+} from './globalOptions';
+
+export const makeCopyCommand = () => {
+  const copy = new Command()
+    .command('copy')
+    .description('copy command')
+    .addHelpText('after', `\n`)
+    .showHelpAfterError(true)
+    .exitOverride();
+
+  copy
+    .command('field')
+    .description('copy the contents of one content type field to another')
+    .argument(
+      '<contentTypeId>',
+      'the api id of the content type containing the fields to copy'
+    )
+    .argument('<fieldId>', 'the id of the field to copy from')
+    .argument('<destinationId>', 'the id of the field to copy to')
+    .option(
+      '-t --template <template>',
+      'apply a liquidjs template (surrounded by double quotes) to modify the copied field content'
+    )
+    .addOption(commit)
+    .addOption(concurrency)
+    .addOption(ignoreErrors)
+    .addOption(outputEntries)
+    .addOption(delivery)
+    .addOption(entryId)
+    .addOption(zenql)
+    .usage('<contentTypeId> <fieldId> <destinationId> (all arguments required)')
+    .addHelpText(
+      'after',
+      `
+Example call:
+  > copy field blog authorName contributors\n
+  > copy field blog description kicker --template "<h2>{{ source_value }}</h2>"\n`
+    )
+    .action(
+      async (
+        contentTypeId: string,
+        fieldId: string,
+        destinationId: string,
+        opts: any
+      ) => {
+        const { template, ...restOpts } = opts;
+        const copyField: CopyField = {
+          contentTypeId,
+          fieldId,
+          destinationId,
+          template: opts.template,
+        };
+
+        return await cliCommand(
+          ['copy', 'project', contentTypeId, fieldId, destinationId],
+          opts,
+          mapContensisOpts({ copyField, ...restOpts })
+        ).CopyEntryField({
+          commit: opts.commit,
+          fromFile: opts.fromFile,
+          logOutput: opts.outputEntries,
+        });
+      }
+    );
+
+  return copy;
+};

package/src/commands/create.ts

@@ -2,7 +2,6 @@ import { Command } from 'commander';
 import { Project } from 'contensis-core-api';
 import { cliCommand } from '~/services/ContensisCliService';
 import { shell } from '~/shell';
-import { isUuid } from '~/util';
 
 export const makeCreateCommand = () => {
   const create = new Command()

package/src/commands/dev.ts

@@ -49,20 +49,28 @@ Example call:
   dev
     .command('requests')
     .description('launch request handler for local development')
-    .argument('[block-ids...]', 'ids of any blocks to develop locally')
+    .argument(
+      '[block-id...]',
+      'id of block to develop locally and the local uri to pass requests for this block onto'
+    )
     .option('--args <args...>', 'override or add additional args')
-    .usage('[block-ids...]')
+    .option(
+      '--release <release>',
+      'launch a specific release version of the request handler'
+    )
+    .usage('[block-id] [local-uri]')
     .addHelpText(
       'after',
       `
 Example call:
-  > dev requests test-block-one\n`
+  > dev requests test-block-one
+  > dev requests my-website http://localhost:8080\n`
     )
-    .action(async (blockIds: string[] = [], opts) => {
+    .action(async (blockId: string[] = [], opts) => {
       await devCommand(
-        ['dev', 'requests', blockIds.join(' ')],
+        ['dev', 'requests', blockId.join(' ')],
         opts
-      ).ExecRequestHandler(blockIds, opts?.args);
+      ).ExecRequestHandler(blockId, opts?.args, opts.release);
     });
 
   return dev;

package/src/commands/get.ts

@@ -215,24 +215,24 @@ Example call:
     });
 
   sharedGetEntryOptions(
-  program
-    .command('entries')
-    .description('get entries')
-    .argument(
-      '[search phrase]',
-      'get entries with the search phrase, use quotes for multiple words'
-    )
+    program
+      .command('entries')
+      .description('get entries')
+      .argument(
+        '[search phrase]',
+        'get entries with the search phrase, use quotes for multiple words'
+      )
       .addOption(contentTypes)
-    .option(
+      .option(
         '-d --dependents',
-      'find and return any dependencies of all found entries'
-    )
+        'find and return any dependencies of all found entries'
+      )
   )
     .addOption(
       new Option(
         '--data-format <dataFormat>',
         'find and return entries of a specific data format'
-    )
+      )
         .choices(['entry', 'asset', 'webpage'])
         .default('entry')
     )
@@ -298,6 +298,7 @@ Example call:
 Example call:
   > get block contensis-website
   > get block contensis-website develop latest
+  > get block contensis-website feature-branch 3
 `
     )
     .action(async (blockId: string, branch: string, version: string, opts) => {

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

@@ -6,7 +6,7 @@ import { LogMessages } from '~/localisation/en-GB';
 import GitHubCliModuleProvider from '~/providers/GitHubCliModuleProvider';
 
 import ManifestProvider from '~/providers/ManifestProvider';
-import { appRootDir, joinPath } from '~/providers/file-provider';
+import { appRootDir, checkDir, joinPath } from '~/providers/file-provider';
 import { isDebug } from '~/util/debug';
 import { Logger } from '~/util/logger';
 
@@ -21,6 +21,7 @@ export class RequestHandlerFactory {
   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}`);
@@ -35,29 +36,31 @@ export class RequestHandlerFactory {
     );
   }
 
-  constructor(prerelease = false) {
+  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 } = this;
-    const firstUse = !moduleInfo?.version || moduleInfo?.version === '*';
+    const { moduleInfo, version } = this;
+    const downloadImmediately =
+      !moduleInfo?.version || moduleInfo?.version === '*' || this.version;
 
-    if (firstUse) {
+    if (downloadImmediately) {
       // Create cli-manifest.json
       this.manifest.writeModule(this.name, this.moduleInfo);
 
       // Download for first time use (await)
-      await this.CheckUpdate({ verbose: true });
+      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 (!firstUse) this.CheckUpdate();
+    if (!downloadImmediately) this.CheckUpdate();
 
     // Return a RequestHandler ready to invoke
     return this.CreateInvoke(this);
@@ -121,11 +124,17 @@ export class RequestHandlerFactory {
     };
   }
 
-  async CheckUpdate({ verbose = false }: { verbose?: boolean } = {}) {
-    const { debug, log, manifest, messages, moduleInfo } = this;
+  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();
+    const release = await github.FindLatestRelease(version);
+
     if (verbose || debug)
       if (release)
         log.info(
@@ -137,10 +146,14 @@ export class RequestHandlerFactory {
       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)
+      (release?.tag_name &&
+        ![moduleInfo.version, moduleInfo.install].includes(release.tag_name)) ||
+      downloadSpecificRelease
     ) {
       // Download platform-specific release asset
       const downloadPath = path.join(
@@ -160,6 +173,7 @@ export class RequestHandlerFactory {
       }
       try {
         await github.DownloadRelease(release, {
+          cmd,
           path: downloadPath,
           // Map NodeJS os platform to release asset name
           platforms: [
@@ -186,10 +200,16 @@ export class RequestHandlerFactory {
             ),
           });
 
-        // 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);
+        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;
+        }
       }
     }
   }
@@ -222,4 +242,5 @@ export class RequestHandlerFactory {
   }
 }
 
-export const createRequestHandler = () => new RequestHandlerFactory().Create();
+export const createRequestHandler = (version?: string) =>
+  new RequestHandlerFactory(version).Create();

package/src/localisation/en-GB.ts

@@ -607,8 +607,7 @@ export const LogMessages = {
     install: {
       notFound: (repo: string) =>
         `Could not find a release in ${repo} repo - please check github`,
-      download: (repo: string, version: string) =>
-        `Found release ${repo} ${version}`,
+      download: (repo: string, version: string) => `Found release ${version}`,
       downloading: (repo: string, version: string) =>
         `Downloading ${repo} ${version}`,
       downloadFail: (repo: string, version: string) =>
@@ -621,6 +620,8 @@ export const LogMessages = {
         )}?`,
     },
     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) =>