contensis-cli 1.6.1-beta.2 → 1.6.1-beta.20

package/src/providers/file-provider.ts

@@ -93,6 +93,9 @@ export const cwdPath = (filePath: string) =>
 
 export const joinPath = path.join;
 
+export const pathExists = (filePath: string) =>
+  fs.existsSync(appPath(filePath));
+
 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);

package/src/services/ContensisCliService.ts

@@ -8,8 +8,10 @@ import clone from 'rfdc';
 
 import { Component, ContentType, Project } from 'contensis-core-api';
 import {
+  ICreateNode,
   ICreateTag,
   ICreateTagGroup,
+  Node,
   Role,
   Tag,
   TagGroup,
@@ -23,6 +25,7 @@ import {
   Model,
   BlockActionType,
   logEntitiesTable,
+  Renderer,
 } from 'migratortron';
 
 import ContensisAuthService from './ContensisAuthService';
@@ -54,6 +57,7 @@ import {
   printModelMigrationResult,
   printNodeTreeOutput,
   printNodesMigrateResult,
+  printWebhooksMigrateResult,
 } from '~/util/console.printer';
 import { csvFormatter } from '~/util/csv.formatter';
 import { htmlFormatter } from '~/util/html.formatter';
@@ -93,6 +97,9 @@ class ContensisCli {
   targetEnv?: string;
   urls: CliUrls;
   log = Logger;
+  /** Currently used to pass to other modules such as migratortron and request handler
+   * and less-so in the CLI service itself */
+  logLevel?: 'debug' | 'info' | 'warning' | 'error' | 'none';
   messages = LogMessages;
 
   verb: string;
@@ -156,6 +163,7 @@ class ContensisCli {
       );
     }
 
+    this.logLevel = outputOpts?.logLevel;
     this.format = outputOpts?.format;
     this.output = outputOpts?.output
       ? path.isAbsolute(outputOpts.output)
@@ -1833,7 +1841,7 @@ class ContensisCli {
       else
         await this.HandleFormattingAndOutput(result, () => {
           // print the results to console
-          if (!result.committed) {
+          if (result && !result?.committed) {
             log.raw(log.boldText(`\nContent types:`));
             if (!result.contentTypes) log.info(`- None returned\n`);
             else printModelMigrationAnalysis(this, result.contentTypes);
@@ -1859,7 +1867,7 @@ class ContensisCli {
               log.object(result.errors);
             }
           } else {
-            const { modelsResult = {} } = result;
+            const { modelsResult = {} } = result || {};
             log.raw(log.boldText(`\nContent types:`));
             printModelMigrationResult(
               this,
@@ -2267,8 +2275,8 @@ class ContensisCli {
         });
       if (
         !err &&
-        ((!commit && result.entriesToMigrate[currentProject].totalCount) ||
-          (commit && result.migrateResult?.deleted))
+        ((!commit && result?.entriesToMigrate[currentProject].totalCount) ||
+          (commit && result?.migrateResult?.deleted))
       ) {
         log.success(messages.entries.removed(currentEnv, commit));
         if (!commit) {
@@ -2357,7 +2365,7 @@ class ContensisCli {
       const [err, result] = await contensis.MigrateEntries();
 
       if (err) logError(err);
-      else {
+      else if (result) {
         const { entries, nodes, tags } =
           contensis.content.targets[currentProject];
 
@@ -2394,19 +2402,24 @@ class ContensisCli {
       }
       if (
         !err &&
-        !result.errors?.length &&
-        ((!commit && result.entriesToMigrate[currentProject].totalCount) ||
+        !result?.errors?.length &&
+        ((!commit && result?.entriesToMigrate[currentProject].totalCount) ||
           (commit &&
-            (result.migrateResult?.created || result.migrateResult?.updated)))
+            (result?.migrateResult?.created ||
+              result?.migrateResult?.updated ||
+              result?.nodesResult?.created ||
+              result?.nodesResult?.updated ||
+              result?.tagsResult?.created ||
+              result?.tagsResult?.updated)))
       ) {
         log.success(
           messages.entries.imported(
             currentEnv,
             commit,
             commit
-              ? (result.migrateResult?.created || 0) +
-                  (result.migrateResult?.updated || 0)
-              : result.entriesToMigrate[currentProject].totalCount,
+              ? (result?.migrateResult?.created || 0) +
+                  (result?.migrateResult?.updated || 0)
+              : result?.entriesToMigrate[currentProject].totalCount,
             commit
               ? (result.nodesResult?.created || 0) +
                   (result.nodesResult?.updated || 0)
@@ -2665,7 +2678,7 @@ class ContensisCli {
       const [err, result] = await contensis.MigrateNodes();
 
       if (err) log.raw(``);
-      else
+      else if (result)
         await this.HandleFormattingAndOutput(result, () => {
           // print the migrateResult to console
           const migrateTree =
@@ -2688,9 +2701,9 @@ class ContensisCli {
 
       if (
         !err &&
-        (!result.errors?.length || this.contensisOpts.ignoreErrors) &&
+        (!result?.errors?.length || this.contensisOpts.ignoreErrors) &&
         ((!commit && nodesMigrateCount) ||
-          (commit && (nodesCreated || nodesUpdated || result.errors?.length)))
+          (commit && (nodesCreated || nodesUpdated || result?.errors?.length)))
       ) {
         let totalCount: number;
         if (commit) {
@@ -2751,8 +2764,8 @@ class ContensisCli {
       }
       if (
         !err &&
-        ((!commit && result.nodesToMigrate[currentProject].totalCount) ||
-          (commit && result.nodesResult?.deleted))
+        ((!commit && result?.nodesToMigrate[currentProject].totalCount) ||
+          (commit && result?.nodesResult?.deleted))
       ) {
         log.success(
           messages.nodes.removed(currentEnv, commit, contensis.nodes.rootPath)
@@ -2769,6 +2782,143 @@ class ContensisCli {
     }
   };
 
+  CreateOrUpdateNode = async (
+    nodePathOrId: string,
+    nodeUpdates: Partial<Node>,
+    displayName?: string | undefined,
+    slug?: string | undefined,
+    language?: string | undefined
+  ) => {
+    const { currentEnv, currentProject, log, messages } = this;
+    const contensis = await this.ConnectContensis();
+
+    const nodePath = nodePathOrId.startsWith('/') ? nodePathOrId : undefined;
+    let nodeId = isUuid(nodePathOrId) ? nodePathOrId : undefined;
+
+    let existingNode: Node | undefined;
+    let parentNode: Node | undefined;
+    let updateNode: Node | undefined;
+
+    if (contensis) {
+      // Retrieve node
+      if (nodePath) {
+        const [, nodesByPath] = await to(contensis.nodes.GetNodes(nodePath, 0));
+
+        if (Array.isArray(nodesByPath) && nodesByPath[0]?.id) {
+          nodeId = nodesByPath[0].id;
+        }
+      }
+
+      if (nodeId) {
+        // Get the management node so we can update it
+        const [, nodeById] = await to(
+          contensis.source.repo.GetNodeById(nodeId)
+        );
+
+        if (nodeById) existingNode = nodeById;
+      }
+
+      // TODO: resolve any renderer id to its uuid so we can support passing the regular id for ease of use
+      if (!existingNode) {
+        // Build a node object to create or reject if there is not enough data
+
+        if (!language) {
+          const project =
+            await contensis.source.repo.GetProject(currentProject);
+          language = project?.primaryLanguage || 'en-GB';
+        }
+
+        if (!nodeUpdates.parentId) {
+          // Find the node's parentId from the path if possible
+          if (!nodePath)
+            throw new Error(
+              `A node with id "${nodeId}" does not exist, and a path was not provided to find the parent node.`
+            );
+
+          const parentPath =
+            nodePath.substring(0, nodePath.lastIndexOf('/')) || '/';
+          const [, parentNodesByPath] = await to(
+            contensis.nodes.GetNodes(parentPath, 0)
+          );
+
+          if (!parentNodesByPath?.[0]?.id)
+            throw new Error(
+              `A node with id "${nodeId}" does not exist, and the parent node could not be found at path "${parentPath}".`
+            );
+          else parentNode = parentNodesByPath[0] as unknown as Node;
+        }
+        const pathSlug = nodePath?.substring(nodePath.lastIndexOf('/') + 1);
+
+        const createNode: ICreateNode = {
+          id: nodeId,
+          parentId: nodeUpdates.parentId || parentNode?.id,
+          projectId: currentProject,
+          displayName: displayName
+            ? {
+                [language]: displayName,
+              }
+            : nodeUpdates.displayName
+              ? nodeUpdates.displayName
+              : pathSlug
+                ? {
+                    [language]: pathSlug,
+                  }
+                : (undefined as any),
+          slug: slug
+            ? {
+                [language]: slug,
+              }
+            : nodeUpdates.slug
+              ? nodeUpdates.slug
+              : pathSlug
+                ? {
+                    [language]: pathSlug,
+                  }
+                : (undefined as any),
+          entryId: nodeUpdates.entryId,
+          isCanonical: nodeUpdates.isCanonical,
+          renderer: nodeUpdates.renderer,
+          proxy: nodeUpdates.proxy,
+          includeInMenu: nodeUpdates.includeInMenu,
+        };
+
+        // Validate createNode
+        updateNode = createNode as Node;
+      } else {
+        updateNode = { ...existingNode, ...nodeUpdates };
+      }
+
+      if (updateNode) {
+        log.info(messages.nodes.setPayload());
+        log.object(updateNode);
+        log.raw('');
+        const [err, newNode] = await contensis.source.repo.UpdateOrCreateNode(
+          existingNode as Node,
+          updateNode
+        );
+
+        if (err)
+          log.error(
+            messages.nodes[existingNode ? 'failedSet' : 'failedCreate'](
+              currentEnv,
+              nodePathOrId
+            ),
+            err
+          );
+        else if (newNode) {
+          log.success(
+            messages.nodes[existingNode ? 'set' : 'created'](
+              currentEnv,
+              newNode.id
+            )
+          );
+
+          await this.HandleFormattingAndOutput(newNode, log.object);
+        }
+      }
+    }
+  };
+
   PrintWebhookSubscriptions = async (subscriptionIdsOrNames?: string[]) => {
     const { currentEnv, log, messages } = this;
     const contensis = await this.ConnectContensis();
@@ -2809,7 +2959,7 @@ class ContensisCli {
             } of filteredResults) {
               console.log(
                 log.infoText(
-                  `  ${chalk.bold.white`- ${name}`} ${id} [${(
+                  `${chalk.bold.white`${enabled ? '🟢' : '🔴'}  ${name}`} ${id} [${(
                     version.modified || version.created
                   )
                     .toString()
@@ -2819,6 +2969,9 @@ class ContensisCli {
                 )
               );
               if (description) console.log(log.infoText`    ${description}`);
+              console.log(
+                `    ${log.infoText`enabled`}: ${chalk[enabled ? 'green' : 'red'](enabled)}`
+              );
               console.log(`    ${log.infoText`[${method}]`} ${url}`);
               if (headers && Object.keys(headers).length) {
                 console.log(`    ${log.infoText`headers`}:`);
@@ -2849,8 +3002,6 @@ class ContensisCli {
                     templates
                   ).join(' ')}`
                 );
-              if (enabled === false)
-                console.log(`    ${log.infoText`enabled`}: ${enabled}`);
             }
           });
         }
@@ -2863,6 +3014,90 @@ class ContensisCli {
     }
   };
 
+  ImportWebhooks = async ({
+    commit,
+    fromFile,
+    logOutput,
+    enabled = false,
+    disabled = false,
+  }: {
+    commit: boolean;
+    fromFile?: string;
+    logOutput: string;
+    enabled?: boolean;
+    disabled?: boolean;
+  }) => {
+    const { currentEnv, currentProject, log, messages } = this;
+
+    const contensis = await this.ConnectContensisImport({
+      commit,
+      fromFile,
+    });
+
+    if (contensis) {
+      log.line();
+      if (contensis.isPreview) {
+        log.success(messages.migrate.preview());
+      } else {
+        log.warning(messages.migrate.commit());
+      }
+
+      const [err, result] = await to(
+        contensis.webhooks.MigrateWebhooks({
+          // trying to simulate XOR logic, setting enabled arg from
+          // enabled or disabled option only if one of them is set
+          enabled: enabled !== disabled ? enabled || !disabled : undefined,
+        })
+      );
+
+      if (err) logError(err);
+      else if (result) {
+        await this.HandleFormattingAndOutput(result, () => {
+          printWebhooksMigrateResult(this, result, {
+            showAll: logOutput === 'all',
+            showDiff: logOutput === 'all' || logOutput === 'changes',
+            showChanged: logOutput === 'changes',
+          });
+        });
+      }
+      if (
+        !err &&
+        !result.errors?.length &&
+        ((!commit && result.webhooksToMigrate[currentProject].totalCount) ||
+          (commit &&
+            (result.webhooksResult?.created || result.webhooksResult?.updated)))
+      ) {
+        log.success(
+          messages.webhooks.imported(
+            currentEnv,
+            commit,
+            commit
+              ? (result.webhooksResult?.created || 0) +
+                  (result.webhooksResult?.updated || 0)
+              : (result.webhooksToMigrate[currentProject].totalCount as number)
+          )
+        );
+        if (!commit) {
+          log.raw(``);
+          log.help(messages.migrate.commitTip());
+        }
+      } else {
+        const noChanges =
+          result?.webhooksToMigrate?.[currentProject]?.['no change'] &&
+          result?.webhooksToMigrate?.[currentProject].totalCount === 0;
+
+        if (noChanges && !err && !result.errors?.length) {
+          log.help(messages.webhooks.noChange(currentEnv));
+        } else {
+          log.error(messages.webhooks.failedCreate(currentEnv), err);
+        }
+      }
+    } else {
+      log.warning(messages.models.noList(currentProject));
+      log.help(messages.connect.tip());
+    }
+  };
+
   PrintBlocks = async () => {
     const { currentEnv, env, log, messages } = this;
     const contensis = await this.ConnectContensis();
@@ -3282,7 +3517,6 @@ class ContensisCli {
     }
   };
 
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   PrintRenderers = async (rendererId?: string) => {
     const { currentEnv, env, log, messages } = this;
     const contensis = await this.ConnectContensis();
@@ -3291,19 +3525,27 @@ class ContensisCli {
       const [err, renderers] = await contensis.renderers.GetRenderers();
 
       if (Array.isArray(renderers)) {
-        await this.HandleFormattingAndOutput(renderers, () => {
+        const result = rendererId
+          ? ([renderers.find(r => r.id === rendererId)].filter(
+              Boolean
+            ) as Renderer[])
+          : renderers || [];
+
+        await this.HandleFormattingAndOutput(result, () => {
           // print the renderers to console
           log.success(messages.renderers.list(currentEnv, env.currentProject));
           for (const {
+            uuid,
             id,
             description,
             assignedContentTypes,
             rules,
             version,
-          } of renderers) {
+          } of result) {
             console.log(
               `  - ${id} [${version.versionNo}] ${log.infoText`${description}`}`
             );
+            console.log(log.infoText`      uuid: ${uuid}`);
             if (assignedContentTypes?.length)
               console.log(
                 log.infoText`      assignedContentTypes: ${assignedContentTypes.join(
@@ -3319,7 +3561,7 @@ class ContensisCli {
                 );
           }
         });
-        return renderers;
+        return result;
       }
 
       if (err) {

package/src/services/ContensisDevService.ts

@@ -1,3 +1,4 @@
+import { search } from '@inquirer/prompts';
 import ansiEscapes from 'ansi-escapes';
 import to from 'await-to-js';
 import inquirer from 'inquirer';
@@ -413,10 +414,11 @@ class ContensisDev extends ContensisRole {
 
   ExecRequestHandler = async (
     blockId: string[],
+    blockOverrides: string[] | boolean,
     overrideArgs: string[] = [],
     version?: string
   ) => {
-    const { debug, log, messages } = this;
+    const { currentEnv, currentProject, debug, log, messages } = this;
 
     const spinner = !debug
       ? createSpinner(messages.devrequests.launch())
@@ -425,43 +427,105 @@ class ContensisDev extends ContensisRole {
     // Ensure request handler is available to use
     const requestHandler = await createRequestHandler(version);
 
-    // Generate args for request handler using CLI methods
-    const args = new RequestHandlerArgs(this);
-    spinner?.start();
-    await args.Create();
-    spinner?.success();
-
-    // Prompt block id and dev uri to run locally (if not supplied)
-    const blockIdChoices = args.siteConfig?.blocks.map(block => block.id) || [];
-    blockIdChoices.push('none');
-    const defaultDeveloperUri = 'http://localhost:3000';
-
-    const { overrideBlockId, overrideUri } = blockId.length
-      ? {
-          overrideBlockId: blockId[0],
-          overrideUri: blockId?.[1] || defaultDeveloperUri,
+    // Get the available blocks for the project
+    const contensis = await this.ConnectContensis();
+    if (contensis) {
+      const blockBranches = new Map<string, string>();
+
+      const [err, projectBlocks] = await contensis.blocks.GetBlocks();
+      if (err) log.error(messages.blocks.noList(currentEnv, currentProject));
+      else if (projectBlocks) {
+        // Prompt block id and dev uri to run locally (if not supplied)
+        const blockIdChoices = projectBlocks.map(block => block.id) || [];
+        blockIdChoices.push('none');
+        const defaultDeveloperUri = 'http://localhost:3000';
+
+        const { developmentBlockId, developmentBlockUri } = blockId.length
+          ? {
+              developmentBlockId: blockId[0],
+              developmentBlockUri: blockId?.[1] || defaultDeveloperUri,
+            }
+          : await inquirer.prompt([
+              {
+                type: 'list',
+                prefix: '🧱',
+                message: messages.devrequests.overrideBlock(),
+                name: 'developmentBlockId',
+                choices: blockIdChoices,
+              },
+              {
+                type: 'input',
+                prefix: '🔗',
+                message: messages.devrequests.overrideUri(),
+                name: 'developmentBlockUri',
+                default: defaultDeveloperUri,
+              },
+            ]);
+
+        // Prompt for other block overrides (e.g. branch)
+        if (blockOverrides) {
+          // Prompt for which blocks to override
+          const blockIdChoices =
+            projectBlocks
+              // ?.filter(block => block.id !== developmentBlockId)
+              ?.map(block => ({
+                name: `${block.id}${block.description ? ` (${block.description})` : ''}`,
+                value: block.id,
+              })) || [];
+          blockIdChoices.push({ name: 'none', value: 'none' });
+
+          const { overrideBlockIds } = Array.isArray(blockOverrides)
+            ? {
+                overrideBlockIds: blockOverrides
+                  .map(bId => projectBlocks.find(b => b.id === bId)?.id)
+                  .filter(Boolean) as string[],
+              }
+            : await inquirer.prompt<{ overrideBlockIds: string[] }>([
+                {
+                  type: 'checkbox',
+                  prefix: '🧱',
+                  message: messages.devrequests.overrideBlocks(),
+                  name: 'overrideBlockIds',
+                  choices: blockIdChoices,
+                  // default: blockIdChoices.findIndex(b => b.value === 'none'),
+                },
+              ]);
+
+          // For each block to override, prompt for the branch to use
+          for (const overrideBlockId of overrideBlockIds) {
+            if (overrideBlockId === 'none') continue;
+            const choices = projectBlocks
+              .find(b => b.id === overrideBlockId)
+              ?.branches.map(b => b.id);
+            if (choices) {
+              const overrideBranch = await search<string>({
+                message: `🌿 ${messages.devrequests.overrideBranch(overrideBlockId)}`,
+                source: input => {
+                  input = input || '';
+                  const fuzzyResult = input
+                    ? choices?.filter(choice =>
+                        choice.toLowerCase().includes(input.toLowerCase())
+                      )
+                    : choices;
+                  return fuzzyResult || [];
+                },
+              });
+              blockBranches.set(overrideBlockId, overrideBranch);
+            }
+          }
         }
-      : await inquirer.prompt([
-          {
-            type: 'list',
-            prefix: '🧱',
-            message: messages.devrequests.overrideBlock(),
-            name: 'overrideBlockId',
-            choices: blockIdChoices,
-          },
-          {
-            type: 'input',
-            prefix: '🔗',
-            message: messages.devrequests.overrideUri(),
-            name: 'overrideUri',
-            default: defaultDeveloperUri,
-          },
-        ]);
 
-    args.overrideBlock(overrideBlockId, overrideUri);
+        // Generate args for request handler using CLI methods
+        const args = new RequestHandlerArgs(projectBlocks, blockBranches, this);
+        spinner?.start();
+        await args.Create();
+        args.overrideBlock(developmentBlockId, developmentBlockUri);
+        spinner?.success();
 
-    // Launch request handler
-    await requestHandler(args.getArgs(overrideArgs));
+        // Launch request handler
+        await requestHandler(args.getArgs(overrideArgs));
+      }
+    }
   };
 }
 export const devCommand = (

package/src/shell.ts

@@ -142,12 +142,15 @@ class ContensisShell {
         'login',
         'list projects',
         'set project',
-        ...(this.env?.projects || []).map(project => `set project ${project.id}`)
+        ...(this.env?.projects || []).map(
+          project => `set project ${project.id}`
+        )
       );
     if (userId)
       availableCommands.push(
         'copy field',
         'create key',
+        'create node',
         'create project',
         'create role',
         'create tag',
@@ -183,6 +186,7 @@ class ContensisShell {
         'import nodes',
         'import tags',
         'import taggroups',
+        'import webhooks',
         'list blocks',
         'list contenttypes',
         'list components',
@@ -207,6 +211,8 @@ class ContensisShell {
         'remove tags',
         'remove tags in',
         'remove taggroup',
+        'set node entry',
+        'set node renderer',
         'set project name',
         'set project description',
         'set role name',