contensis-cli 1.2.2-beta.8 → 1.3.0

package/src/commands/get.ts

@@ -7,9 +7,11 @@ import {
   contentTypes,
   delivery,
   entryId,
+  exportOption,
   latest,
   mapContensisOpts,
   noCache,
+  requiredBy,
   versionStatus,
   zenql,
 } from './globalOptions';
@@ -67,6 +69,38 @@ Example call:
       );
     });
 
+  program
+    .command('proxy')
+    .description('get a proxy')
+    .argument('<proxyId>', 'id of the proxy to get')
+    .addHelpText(
+      'after',
+      `
+  Example call:
+    > get proxy b8b6958f-6ae2-41d5-876a-abc86755fd7b
+  `
+    )
+    .action(async (proxyId: string, opts) => {
+      await cliCommand(['get', 'proxy', proxyId], opts).PrintProxies(proxyId);
+    });
+
+  program
+    .command('renderer')
+    .description('get a renderer')
+    .argument('<rendererId>', 'id of the renderer to get')
+    .addHelpText(
+      'after',
+      `
+Example call:
+  > get renderer contensis-website
+`
+    )
+    .action(async (rendererId: string, opts) => {
+      await cliCommand(['get', 'renderer', rendererId], opts).PrintRenderers(
+        rendererId
+      );
+    });
+
   program
     .command('role')
     .description('get a role')
@@ -124,7 +158,8 @@ Example call:
     .command('model')
     .description('get a content model')
     .argument('<contentTypeId...>', 'ids of the content models to get')
-    .option('--required-by', 'shows the id(s) that created each dependency')
+    .addOption(requiredBy)
+    .addOption(exportOption)
     .addOption(noCache)
     .addHelpText(
       'after',
@@ -138,7 +173,7 @@ Example call:
         ['get', 'model', modelIds.join(' ')],
         opts,
         mapContensisOpts(opts)
-      ).PrintContentModels(modelIds, opts.requiredBy);
+      ).PrintContentModels(modelIds, opts);
     });
 
   program
@@ -221,7 +256,7 @@ Example call:
         ['get', 'assets'],
         opts,
         mapContensisOpts({ dataFormat: 'asset', search, ...opts })
-      ).GetEntries({});
+      ).GetEntries();
     });
 
   sharedGetEntryOptions(

package/src/commands/globalOptions.ts

@@ -46,7 +46,8 @@ export const mapContensisOpts = (opts: any = {}): MigrateRequest => ({
   zenQL: opts.zenql,
   transformGuids: !opts.preserveGuids,
   ignoreErrors: opts.ignoreErrors,
-  noCache: !opts.cache,
+  noCache: !opts.cache, // arg is inverted automatically from `--no-cache` to `cache: false`
+  includeDefaults: opts.defaults, // arg is inverted automatically from `--no-defaults` to `defaults: false`
   concurrency: opts.concurrency ? Number(opts.concurrency) : undefined,
 });
 
@@ -90,6 +91,16 @@ const sharedSecret = new Option(
   'the shared secret to use when logging in with a client id'
 );
 
+/* Model get options */
+export const requiredBy = new Option(
+  '--required-by',
+  'shows the id(s) that created each dependency'
+);
+export const exportOption = new Option(
+  '--export',
+  'export the raw resources that make up the content model(s) (used with --output)'
+);
+
 /* Entry get options */
 export const delivery = new Option(
   '-delivery --delivery-api',
@@ -156,7 +167,7 @@ export const outputDetail = new Option(
 
 export const saveEntries = new Option(
   '-save --save-entries',
-  "save the entries we're migrating instead of the migration preview when using --output option"
+  "save the entries we're migrating instead of the migration preview (used with --output)"
 );
 
 export const concurrency = new Option(

package/src/commands/import.ts

@@ -30,6 +30,14 @@ export const makeImportCommand = () => {
     .argument('[modelIds...]', 'ids of the content models to import (optional)')
     .addOption(noCache)
     .addOption(commit)
+    .option(
+      '-nod --no-defaults',
+      'ignore any default entries or nodes attached to content types or fields'
+    )
+    .option(
+      '-preserve --preserve-guids',
+      'import any default entries or nodes using the same id as the source'
+    )
     .addHelpText(
       'after',
       `

package/src/commands/list.ts

@@ -1,6 +1,6 @@
 import { Command } from 'commander';
 import { cliCommand } from '~/services/ContensisCliService';
-import { mapContensisOpts, noCache } from './globalOptions';
+import { exportOption, mapContensisOpts, noCache } from './globalOptions';
 
 export const makeListCommand = () => {
   const list = new Command()
@@ -41,6 +41,7 @@ Example call:
   list
     .command('models')
     .description('print list of content models')
+    .addOption(exportOption)
     .addOption(noCache)
     .addHelpText(
       'after',
@@ -54,7 +55,7 @@ Example call:
         ['list', 'models'],
         opts,
         mapContensisOpts(opts)
-      ).PrintContentModels();
+      ).PrintContentModels([], opts);
     });
 
   list

package/src/commands/push.ts

@@ -51,7 +51,7 @@ export const makePushCommand = () => {
     )
     .option(
       '-pr --provider <sourceProvider>',
-      'the url of the source repository for the supplied image uri'
+      'the source repository provider of the supplied image uri'
     )
     .usage('<block-id> <image uri> [branch] [options]')
     .addHelpText(

package/src/services/ContensisCliService.ts

@@ -4,6 +4,7 @@ import fs from 'fs';
 import inquirer from 'inquirer';
 import fetch from 'node-fetch';
 import path from 'path';
+import clone from 'rfdc';
 
 import { Component, ContentType, Project } from 'contensis-core-api';
 import { Role } from 'contensis-management-api/lib/models';
@@ -1178,7 +1179,7 @@ class ContensisCli {
 
   PrintContentModels = async (
     modelIds: string[] = [],
-    printRequiredBy?: boolean
+    opts: { export?: boolean; requiredBy?: boolean }
   ) => {
     const { currentProject, log, messages } = this;
     const contensis = await this.ConnectContensis();
@@ -1194,93 +1195,112 @@ class ContensisCli {
             modelIds.some(id => id.toLowerCase() === m.id.toLowerCase())
           )
         : undefined;
+      const exportResources: (ContentType | Component)[] = [];
+
+      if (opts.export) {
+        // Generate a list of contentTypeIds and componentIds from all models
+        // and dependencies
+        const contentTypeIds = Array.from(
+          new Set([
+            ...(returnModels || models || []).map(m => m.id),
+            ...(returnModels || models || [])
+              .map(m => m.dependencies?.contentTypes?.map(c => c[0]) || [])
+              .flat(),
+          ])
+        );
+        const componentIds = Array.from(
+          new Set(
+            (returnModels || models || [])
+              .map(m => m.dependencies?.components?.map(c => c[0]) || [])
+              .flat()
+          )
+        );
 
-      // Generate a list of contentTypeIds and componentIds from all models
-      // and dependencies
-      const contentTypeIds = Array.from(
-        new Set([
-          ...(returnModels || models || []).map(m => m.id),
-          ...(returnModels || models || [])
-            .map(m => m.dependencies?.contentTypes?.map(c => c[0]) || [])
-            .flat(),
-        ])
-      );
-      const componentIds = Array.from(
-        new Set(
-          (returnModels || models || [])
-            .map(m => m.dependencies?.components?.map(c => c[0]) || [])
-            .flat()
-        )
-      );
-
-      // Create an array of all the content types and component definitions
-      // we will use this when outputting to a file
-      const contentModelBackup = [
-        ...contentTypes.filter(c =>
-          contentTypeIds.map(i => i.toLowerCase()).includes(c.id.toLowerCase())
-        ),
-        ...components.filter(c =>
-          componentIds.map(i => i.toLowerCase()).includes(c.id.toLowerCase())
-        ),
-      ];
+        // Create an array of all the content types and component definitions
+        // we will use this when outputting to a file
+        exportResources.push(
+          ...contentTypes.filter(c =>
+            contentTypeIds
+              .map(i => i.toLowerCase())
+              .includes(c.id.toLowerCase())
+          ),
+          ...components.filter(c =>
+            componentIds.map(i => i.toLowerCase()).includes(c.id.toLowerCase())
+          )
+        );
+      }
 
       if (Array.isArray(returnModels)) {
         log.success(messages.models.list(currentProject));
-        await this.HandleFormattingAndOutput(contentModelBackup, () => {
-          // print the content models to console
-          for (const model of returnModels) {
-            if (!printRequiredBy) {
-              // truncate parts of the output
-              delete model.dependencyOf;
-              if (model.dependencies?.contentTypes)
-                model.dependencies.contentTypes.forEach(id => (id[1] = []));
-              if (model.dependencies?.components)
-                model.dependencies.components.forEach(id => (id[1] = []));
-            }
+        await this.HandleFormattingAndOutput(
+          opts.export ? exportResources : returnModels,
+          () => {
+            // print the content models to console
+            for (const model of returnModels) {
+              // create a clone of each model to safely modify
+              const draft = clone()(model);
+              if (!opts.requiredBy) {
+                // truncate parts of the output
+                delete draft.dependencyOf;
+                if (draft.dependencies?.contentTypes)
+                  draft.dependencies.contentTypes.forEach(id => id.pop());
+                if (draft.dependencies?.components)
+                  draft.dependencies.components.forEach(id => id.pop());
+              }
 
+              log.raw('');
+              log.object(draft);
+            }
             log.raw('');
-            log.object(model);
           }
-          log.raw('');
-        });
+        );
       } else {
         log.success(
           messages.models.get(currentProject, models?.length.toString() || '0')
         );
         log.raw('');
         if (models?.length) {
-          await this.HandleFormattingAndOutput(contentModelBackup, () => {
-            // print the content models to console
-            for (const model of models) {
-              const components = model.components?.length || 0;
-              const contentTypes = model.contentTypes?.length || 0;
-              const dependencies =
-                (model.dependencies?.components?.length || 0) +
-                (model.dependencies?.contentTypes?.length || 0);
-              const dependencyOf =
-                (model.dependencyOf?.components?.length || 0) +
-                (model.dependencyOf?.contentTypes?.length || 0);
-
-              const hasAny =
-                components + contentTypes + dependencies + dependencyOf;
-              log.raw(
-                `  - ${log.highlightText(log.boldText(model.id))} ${
-                  hasAny
-                    ? log.infoText(
-                        `{ ${components ? `components: ${components}, ` : ''}${
-                          contentTypes ? `contentTypes: ${contentTypes}, ` : ''
-                        }${
-                          dependencies ? `references: ${dependencies}, ` : ''
-                        }${
-                          dependencyOf ? `required by: ${dependencyOf}` : ''
-                        } }`
-                      )
-                    : ''
-                }`
-              );
+          await this.HandleFormattingAndOutput(
+            opts.export ? exportResources : models,
+            () => {
+              // print the content models to console
+              for (const model of models) {
+                const components = model.components?.length || 0;
+                const contentTypes = model.contentTypes?.length || 0;
+                const defaults =
+                  (model.defaults?.length || 0) + (model.nodes?.length || 0);
+                const dependencies =
+                  (model.dependencies?.components?.length || 0) +
+                  (model.dependencies?.contentTypes?.length || 0);
+                const dependencyOf =
+                  (model.dependencyOf?.components?.length || 0) +
+                  (model.dependencyOf?.contentTypes?.length || 0);
+
+                const hasAny =
+                  components + contentTypes + dependencies + dependencyOf;
+                log.raw(
+                  `  - ${log.highlightText(log.boldText(model.id))} ${
+                    hasAny
+                      ? log.infoText(
+                          `{ ${
+                            components ? `components: ${components}, ` : ''
+                          }${
+                            contentTypes
+                              ? `contentTypes: ${contentTypes}, `
+                              : ''
+                          }${defaults ? `defaults: ${defaults}, ` : ''}${
+                            dependencies ? `references: ${dependencies}, ` : ''
+                          }${
+                            dependencyOf ? `required by: ${dependencyOf}` : ''
+                          } }`
+                        )
+                      : ''
+                  }`
+                );
+              }
+              log.raw('');
             }
-            log.raw('');
-          });
+          );
         }
       }
     }
@@ -1321,7 +1341,7 @@ class ContensisCli {
       else
         await this.HandleFormattingAndOutput(result, () => {
           // print the results to console
-          if (!commit) {
+          if (!result.committed) {
             log.raw(log.boldText(`\nContent types:`));
             if (!result.contentTypes) log.info(`- None returned\n`);
             else printModelMigrationAnalysis(this, result.contentTypes);
@@ -1329,19 +1349,60 @@ class ContensisCli {
             log.raw(log.boldText(`\nComponents:`));
             if (!result.components) log.info(`- None returned\n`);
             else printModelMigrationAnalysis(this, result.components);
+
+            if (Object.keys(result.defaults).length) {
+              log.raw(log.boldText(`\nDefaults:`));
+              printModelMigrationAnalysis(this, result.defaults);
+            }
+            if (Object.keys(result.nodes).length) {
+              log.raw(log.boldText(`\nNodes:`));
+              printModelMigrationAnalysis(this, result.nodes);
+            }
+            if (result.errors) {
+              log.raw(log.boldText(`\nErrors:`));
+              log.object(result.errors);
+            }
           } else {
-            const migrateResult = result as MigrateModelsResult;
+            const { modelsResult = {} } = result;
             log.raw(log.boldText(`\nContent types:`));
             printModelMigrationResult(
               this,
-              migrateResult[currentProject].contentTypes
-            );
-
-            log.raw(log.boldText(`\nComponents:`));
-            printModelMigrationResult(
-              this,
-              migrateResult[currentProject].components
+              modelsResult[currentProject].contentTypes
             );
+            // Only output for components if any status has any results
+            if (
+              Object.values(modelsResult[currentProject].components).some(
+                r => r.length > 0
+              )
+            ) {
+              log.raw(log.boldText(`\nComponents:`));
+              printModelMigrationResult(
+                this,
+                modelsResult[currentProject].components
+              );
+            }
+            if (
+              Object.values(modelsResult[currentProject].defaults).some(
+                r => r.length > 0
+              )
+            ) {
+              log.raw(log.boldText(`\nDefaults:`));
+              printModelMigrationResult(
+                this,
+                modelsResult[currentProject].defaults
+              );
+            }
+            if (
+              Object.values(modelsResult[currentProject].nodes).some(
+                r => r.length > 0
+              )
+            ) {
+              log.raw(log.boldText(`\nNodes:`));
+              printModelMigrationResult(
+                this,
+                modelsResult[currentProject].nodes
+              );
+            }
           }
         });
     } else {
@@ -1529,14 +1590,15 @@ class ContensisCli {
               `"${result.query.modelIds?.join(', ')}"`
             )}\n`
           );
+          if (result.committed === false) {
+            log.raw(log.boldText(`Content types:`));
+            if (!result.contentTypes) log.info(`- None returned\n`);
+            else printModelMigrationAnalysis(this, result.contentTypes);
 
-          log.raw(log.boldText(`Content types:`));
-          if (!result.contentTypes) log.info(`- None returned\n`);
-          else printModelMigrationAnalysis(this, result.contentTypes);
-
-          log.raw(log.boldText(`Components:`));
-          if (!result.components) log.info(`- None returned\n`);
-          else printModelMigrationAnalysis(this, result.components);
+            log.raw(log.boldText(`\nComponents:`));
+            if (!result.components) log.info(`- None returned\n`);
+            else printModelMigrationAnalysis(this, result.components);
+          }
         });
     }
   };
@@ -1727,13 +1789,19 @@ class ContensisCli {
     withDependents = false,
   }: {
     withDependents?: boolean;
-  }) => {
+  } = {}) => {
     const { currentProject, log, messages } = this;
     const contensis = await this.ConnectContensis();
 
     if (contensis) {
       log.line();
       const entries = await contensis.GetEntries({ withDependents });
+      // TODO: iterate entries and add some extra details to help
+      // with importing later
+      // Add a full sys.uri to asset entries
+      // Add sys.metadata.exportCms
+      // Add sys.metadata.exportProjectId
+
       await this.HandleFormattingAndOutput(entries, () =>
         // print the entries to console
         logEntitiesTable({
@@ -1779,11 +1847,10 @@ class ContensisCli {
 
       if (err) logError(err);
       else {
-        const { migrateEntries, nodes } =
-          contensis.content.targets[currentProject];
+        const { entries, nodes } = contensis.content.targets[currentProject];
 
         const output = saveEntries
-          ? migrateEntries?.map(me => me.finalEntry)
+          ? entries.migrate?.map(me => me.toJSON())
           : result;
         await this.HandleFormattingAndOutput(output, () => {
           // print the migrateResult to console
@@ -1875,8 +1942,8 @@ class ContensisCli {
       if (err) logError(err);
       if (result) {
         const output = saveEntries
-          ? contensis.content.copy.targets[currentProject].migrateEntries?.map(
-              me => me.finalEntry
+          ? contensis.content.copy.targets[currentProject].entries.migrate?.map(
+              me => me.toJSON()
             )
           : result;
         await this.HandleFormattingAndOutput(output, () => {

package/src/shell.ts

@@ -1,6 +1,7 @@
 import figlet from 'figlet';
 import inquirer from 'inquirer';
 import inquirerPrompt from 'inquirer-command-prompt';
+import { split } from 'split-cmd';
 import commands from './commands';
 import { LogMessages } from './localisation/en-GB';
 import CredentialProvider from './providers/CredentialProvider';
@@ -222,9 +223,10 @@ class ContensisShell {
             if (answers.cmd) {
               const program = commands();
               await program.parseAsync(
-                answers.cmd
-                  .match(/"[^"]+"|[^\s]+/g)
-                  ?.map(e => e.replace(/"(.+)"/, '$1')),
+                split(answers.cmd).map(e => e.replace(/\\"/g, '"')),
+                // answers.cmd
+                //   .match(/"[^"]+"|[^\s]+/g)
+                //   ?.map(e => e.replace(/"(.+)"/, '$1')),
                 {
                   from: 'user',
                 }

package/src/util/console.printer.ts

@@ -393,7 +393,11 @@ export const printModelMigrationAnalysis = (
     string,
     any
   ][]) {
-    let mainOutput = log.standardText(`  - ${contentTypeId}`);
+    let mainOutput = log.standardText(
+      `  - ${contentTypeId}${
+        model.contentTypeId ? ` ${log.helpText(model.contentTypeId)}` : ''
+      }`
+    );
     let extraOutput = '';
     let errorOutput = '';
     let diffOutput = '';
@@ -416,12 +420,14 @@ export const printModelMigrationAnalysis = (
           mainOutput += log.infoText(
             ` [${messages.migrate.status(projectDetails.status)(
               `${projectId}: ${projectDetails.status}`
-            )}] v${projectDetails.versionNo}`
+            )}]${
+              projectDetails.versionNo ? ` v${projectDetails.versionNo}` : ''
+            }`
           );
           if (projectDetails.diff)
             diffOutput += `      ${log.highlightText(`diff:`)} ${log.infoText(
               highlightDiffText(projectDetails.diff)
-            )}\n`;
+            )}`;
           if (projectDetails.error)
             errorOutput += `      ${log.highlightText(
               `error::`

package/src/util/csv.formatter.ts

@@ -13,26 +13,42 @@ export const csvFormatter = async <T>(entries: T | T[]) => {
 
   // Parse the flattened object to csv
   // const csv = stringify(flatEntries, { header: true });
+  // Create an exhaustive list of columns from the entries array
+  const columns = new Set<string>(flatEntries.map(e => Object.keys(e)).flat());
   const csv = await new Promise<string>((resolve, reject) => {
-    stringify(flatEntries, { header: true }, (err, data) => {
-      if (err) reject(err);
-      resolve(data);
-    });
+    stringify(
+      flatEntries,
+      {
+        header: true,
+        cast: { boolean: (value, context) => `${value}` },
+        columns: [...columns],
+      },
+      (err, data) => {
+        if (err) reject(err);
+        resolve(data);
+      }
+    );
   });
   return csv;
 };
 
 export const csvToJson = async <T = any>(data: string): Promise<T[]> => {
-  // return parse(data, {
-  //   columns: true,
-  //   skip_empty_lines: true,
-  // });
   return new Promise((resolve, reject) => {
     parse(
       data,
       {
         columns: true,
         skip_empty_lines: true,
+        cast: (value, context) => {
+          if (context.header || context.column === 'sys.version.versionNo')
+            return value;
+          if (value === '') return undefined;
+          try {
+            return JSON.parse(value);
+          } catch (e) {
+            return value;
+          }
+        },
       },
       (err, records) => {
         if (err) reject(err);

package/src/util/json.formatter.ts

@@ -7,11 +7,13 @@ export const jsonFormatter = <T>(obj: T, fields?: string[]) =>
 
 // Flatten a JSON object such as an entry so there are no
 // nested object and the keys are presented like "sys.version.versionNo": "1.0"
-export const flattenObject = (obj: any) => flatten(cleaner(obj, ['workflow']));
+export const flattenObject = (obj: any) =>
+  flatten(cleaner(obj, ['workflow']), { maxDepth: 99 });
 
 // Unflatten a JSON object such as an entry so the arrays and
 // nested objects are reconstructed - the opposite of flattenObject
-export const unflattenObject = (obj: any) => unflatten(obj);
+export const unflattenObject = (obj: any) =>
+  unflatten(obj, { overwrite: true });
 
 // Will limit and sort an object's keys by an array of supplied fields
 export const limitFields = (obj: any, fields?: string[]): any => {

package/src/util/logger.ts

@@ -140,6 +140,14 @@ export class Logger {
                               ' | '
                             )}`
                           : ''
+                      }${
+                        field.dataFormat === 'contenttype'
+                          ? `[${field.validations?.allowedDataFormats.dataFormats.join(
+                              ' | '
+                            )}], ${(
+                              field.validations?.allowedIds?.ids || ['*']
+                            ).join(' | ')}`
+                          : ''
                       }>`
                     : ''
                 }${
@@ -195,11 +203,22 @@ export class Logger {
             if (item.length)
               Logger.raw(chalk.grey(`${indent}  [${item.join(', ')}]`));
             else Logger.objectRecurse(item, depth + 1, `${indent}  `);
+          else
+            Array.isArray(item)
+              ? Logger.raw(
+                  `${indent}${chalk.grey(`[`)}${item.join(', ')}${chalk.grey(
+                    `]`
+                  )}`
+                )
+              : typeof item === 'object' && item
+              ? Logger.objectRecurse(item, depth + 1, `${indent}  `)
+              : Logger.raw(`${indent}${item}`);
         } else Logger.raw(`${indent}${item}`);
       }
     } else {
       let pos = 0;
       for (const [key, value] of Object.entries(content)) {
+        if (key === 'stack') continue; // skip stack output for errors
         const thisIndent =
           pos === 0 ? `${indent.substring(0, indent.length - 2)}- ` : indent;
         if (Array.isArray(value)) {