@jungvonmatt/contentful-migrations 5.6.1 → 6.0.0

package/lib/config.js

@@ -1,7 +1,5 @@
 const path = require('path');
-const inquirer = require('inquirer');
-const mergeOptions = require('merge-options').bind({ ignoreUndefined: true });
-const { cosmiconfig } = require('cosmiconfig');
+const { Confirm } = require('enquirer');
 
 const { getSpaces, getEnvironments } = require('./contentful');
 
@@ -15,101 +13,50 @@ const STATE_FAILURE = 'failure';
  * Get configuration
  * @param {Object} args
  */
-const getConfig = async (args) => {
-  const defaultOptions = {
-    fieldId: 'migration',
-    migrationContentTypeId: 'contentful-migrations',
-    host: 'api.contentful.com',
-    directory: path.resolve(process.cwd(), 'migrations'),
-  };
-
-  const environmentOptions = {
-    spaceId: process.env.CONTENTFUL_SPACE_ID,
-    environmentId: process.env.CONTENTFUL_ENVIRONMENT_ID,
-    accessToken: process.env.CONTENTFUL_MANAGEMENT_TOKEN,
-  };
-
-  let contentfulCliOptions = {};
-  try {
-    // get configuration from contentful rc file (created by the contentful cli command)
-    const explorer = cosmiconfig('contentful');
-    const explorerResult = await explorer.search();
-    if (explorerResult !== null) {
-      const { config } = explorerResult || {};
-      const { managementToken, activeSpaceId, activeEnvironmentId, host } = config || {};
-      contentfulCliOptions = {
-        spaceId: activeSpaceId,
-        accessToken: managementToken,
-        host,
-      };
-    }
-  } catch (error) {
-    console.log('Error:', error.message);
-  }
-
-  let configFileOptions = {};
-  try {
-    // get configuration from migrations rc file
-    const explorer = cosmiconfig('migrations');
-    const explorerResult = args.config ? await explorer.load(args.config) : await explorer.search();
-    if (explorerResult !== null) {
-      const { config, filepath } = explorerResult || {};
-
-      configFileOptions = {
-        directory: path.resolve(path.dirname(filepath || ''), args.directory || 'migrations'),
-        ...(config || {}),
-      };
+const getConfig = async (args, required = []) => {
+  const { configFile, cwd, ...overrides } = args;
+  const { loadContentfulConfig } = await import('@jungvonmatt/contentful-config');
+  const result = await loadContentfulConfig('migrations', {
+    configFile,
+    cwd,
+    overrides,
+    defaultConfig: {
+      fieldId: 'migration',
+      migrationContentTypeId: 'contentful-migrations',
+      host: 'api.contentful.com',
+      directory: path.resolve(cwd || process.cwd(), 'migrations'),
+    },
+    envMap: {
+      CONTENTFUL_SPACE_ID: 'spaceId',
+      CONTENTFUL_ENVIRONMENT_ID: 'environmentId',
+      CONTENTFUL_MANAGEMENT_TOKEN: 'managementToken',
+      CONTENTFUL_HOST: 'host',
+      CONTENTFUL_PROXY: 'proxy',
+      CONTENTFUL_MIGRATIONS_STORAGE: 'storage',
+      CONTENTFUL_MIGRATIONS_FIELD_ID: 'fieldId',
+      CONTENTFUL_MIGRATIONS_CONTENT_TYPE_ID: 'migrationContentTypeId',
+      CONTENTFUL_MIGRATIONS_DIRECTORY: 'directory',
+      CONTENTFUL_MIGRATIONS_REQUEST_BATCH_SIZE: 'requestBatchSize',
+    },
+    prompts: getPromts,
+    required,
+  });
 
-      if (configFileOptions.directory && !path.isAbsolute(configFileOptions.directory)) {
-        configFileOptions.directory = path.resolve(path.dirname(filepath || ''), configFileOptions.directory);
-      }
-    }
-  } catch (error) {
-    console.log('Error:', error.message);
-  }
+  const missingStorage = result.missing.includes('storage');
 
-  return mergeOptions(defaultOptions, contentfulCliOptions, environmentOptions, configFileOptions, args || {});
+  return { ...result.config, missingStorageModel: missingStorage && result.config.storage === STORAGE_CONTENT };
 };
 
+/**
+ * Add prompts for migration specific config fields.
+ * All default contentful prompts are already available via @jungvonmatt/contentful-config
+ * @param {*} data
+ * @returns
+ */
 const getPromts = (data) => {
   return [
     {
-      type: 'input',
-      name: 'accessToken',
-      message: 'Management Token',
-      default: function () {
-        return data.accessToken;
-      },
-    },
-    {
-      type: 'list',
-      name: 'spaceId',
-      message: 'Space ID',
-      choices: async (answers) => {
-        const spaces = await getSpaces({ ...(data || {}), ...answers });
-        return spaces.map((space) => ({
-          name: `${space.name} (${space.sys.id})`,
-          value: space.sys.id,
-        }));
-      },
-      default: function () {
-        return data.spaceId;
-      },
-    },
-    {
-      type: 'list',
-      name: 'environmentId',
-      message: 'Environment ID',
-      choices: async (answers) => {
-        const environments = await getEnvironments({ ...(data || {}), ...answers });
-        return environments.map((environment) => environment.sys.id);
-      },
-      default: function () {
-        return data.environmentId;
-      },
-    },
-    {
-      type: 'list',
+      type: 'select',
       name: 'storage',
       message: 'How should the migrations be managed',
       choices: [
@@ -122,87 +69,50 @@ const getPromts = (data) => {
           value: STORAGE_TAG,
         },
       ],
-      default: function () {
-        return data.fieldId;
-      },
+      initial: data.fieldId,
     },
     {
       type: 'input',
       name: 'fieldId',
       message: 'Id of the tag where the the migration version is stored',
-      when(answers) {
-        return answers.storage === STORAGE_TAG;
-      },
-      default: function () {
-        return data.fieldId;
+      skip(answers) {
+        return answers.storage === STORAGE_CONTENT;
       },
+      initial: data.fieldId,
     },
     {
       type: 'input',
       name: 'migrationContentTypeId',
       message: 'Id of the content-type where the the migrations are stored',
-      when(answers) {
-        return answers.storage === STORAGE_CONTENT;
-      },
-      default: function () {
-        return data.migrationContentTypeId;
+      skip(answers) {
+        return answers.storage === STORAGE_TAG;
       },
+      initial: data.migrationContentTypeId,
     },
     {
       type: 'input',
       name: 'directory',
       message: 'Directory where the migrations are stored',
-      default: function () {
-        return data.directory;
-      },
+      initial: data.directory,
     },
   ];
 };
 
-const askAll = async (data = {}) => {
-  console.log('Please verify the following options');
-
-  const answers = await inquirer.prompt(getPromts(data));
-  answers.directory = path.resolve(process.cwd(), answers.directory || data.directory);
-
-  return answers;
-};
-
-const askMissing = async (data = {}, requiredFields = undefined) => {
-  const allQuestions = getPromts(data);
-  if (!requiredFields) {
-    requiredFields = allQuestions.map(({ name }) => name);
-  }
-
-  const missingPromts = getPromts(data).filter(({ name }) => !data[name] && requiredFields.includes(name));
-
-  // Check if storage changed to content and run initialization
-  const missingStorage = missingPromts.some((prompt) => prompt.name === 'storage');
-  const answers = await inquirer.prompt(missingPromts);
-  const { storage } = answers;
-
-  return { ...data, ...answers, missingStorageModel: missingStorage && storage === STORAGE_CONTENT };
-};
-
 const confirm = async (config = {}) => {
   if (config.yes) {
     return true;
   }
-  const { check } = await inquirer.prompt([
-    {
-      type: 'confirm',
-      name: 'check',
-      message: 'Do you wish to proceed?',
-      default: true,
-    },
-  ]);
 
-  return check;
+  const prompt = new Confirm({
+    name: 'check',
+    message: config?.message || 'Do you wish to proceed?',
+    initial: true,
+  });
+
+  return prompt.run();
 };
 
 module.exports.getConfig = getConfig;
-module.exports.askAll = askAll;
-module.exports.askMissing = askMissing;
 module.exports.confirm = confirm;
 module.exports.STORAGE_TAG = STORAGE_TAG;
 module.exports.STORAGE_CONTENT = STORAGE_CONTENT;

package/lib/content.js

@@ -52,7 +52,7 @@ const transferContent = async (config) => {
     destEnvironmentId,
     spaceId,
     contentType,
-    accessToken: managementToken,
+    managementToken,
   } = config || {};
   // Check migration version
   const sourceVersion = await getLatestVersion({ ...config, environmentId: sourceEnvironmentId });
@@ -133,7 +133,7 @@ const transferContent = async (config) => {
   });
 
   // just a small helper to add a line break after the inquiry
-  const br = diffConflicts && Object.keys(entryOverwrites).length ? '\n' : '';
+  const br = diffConflicts ? '\n' : '';
 
   if (assets.length === 0 && entries.length === 0) {
     console.log(pc.green(`${br}All done`), '🚀');

package/lib/contentful.js

@@ -20,7 +20,6 @@ const LINK_TYPE_ASSET = 'Asset';
 const LINK_TYPE_ENTRY = 'Entry';
 
 const MAX_ALLOWED_LIMIT = 1000;
-const DEFAULT_ENVIRONMENT_ID = 'master';
 
 const getContentTypeId = (node) => {
   const { sys } = node || {};
@@ -63,21 +62,21 @@ const getContentName = (node, displayField) => {
 };
 
 const getClient = async (options) => {
-  const { accessToken, host } = options || {};
+  const { managementToken, host } = options || {};
 
   if (client) {
     return client;
   }
 
   const params = {
-    accessToken,
+    accessToken: managementToken,
   };
 
   if (host) {
     params.host = host;
   }
 
-  if (accessToken) {
+  if (params.accessToken) {
     client = await contentful.createClient(params);
     return client;
   }

package/lib/helpers/validation.d.ts

@@ -1,7 +1,7 @@
 import type Migration from "contentful-migration";
 import type { MigrationContext } from "contentful-migration";
 
-export type ValueMappingFunction = (values: string[]) => string[];
+export type ValueMappingFunction<T extends string = string> = (values: T[]) => T[];
 
 export type AddValuesOptionMode = 'sorted' | 'start' | 'end' | 'before' | 'after';
 
@@ -10,13 +10,36 @@ export interface AddValuesOptions {
   ref?: string;
 }
 
+// define some known mark and node values here to support code completion, but allow any string as well
+export type RichTextMarks = 'bold' | 'italic' | 'underline' | 'code' | 'superscript' | 'subscript' | 'strikethrough' | string & {};
+export type RichTextNodeType = 'document' | 'paragraph' | 'heading-1' | 'heading-2' | 'heading-3' | 'heading-4' | 'heading-5' | 'heading-6' | 'ordered-list' | 'unordered-list' | 'list-item' | 'hr' | 'blockquote' | 'embedded-entry-block' | 'embedded-asset-block' | 'embedded-resource-block' | 'table' | 'table-row' | 'table-cell' | 'table-header-cell' | 'asset-hyperlink' | 'embedded-entry-inline' | 'embedded-resource-inline' | 'entry-hyperlink' | 'hyperlink' | 'resource-hyperlink' | string & {};
+
+export type RichTextLinkedNodeType = 'entry-hyperlink' | 'embedded-entry-block' | 'embedded-entry-inline'
+
+export interface RichTextValidationHelpers {
+  addEnabledMarksValues(contentTypeId: string, fieldId: string, values: RichTextMarks | RichTextMarks[]): Promise<void>;
+  removeEnabledMarksValues(contentTypeId: string, fieldId: string, values: RichTextMarks | RichTextMarks[]): Promise<void>;
+  modifyEnabledMarksValues(contentTypeId: string, fieldId: string, valueMappingFunction: ValueMappingFunction<RichTextMarks>): Promise<void>;
+
+  addEnabledNodeTypeValues(contentTypeId: string, fieldId: string, values: RichTextNodeType | RichTextNodeType[]): Promise<void>;
+  removeEnabledNodeTypeValues(contentTypeId: string, fieldId: string, values: RichTextNodeType | RichTextNodeType[]): Promise<void>;
+  modifyEnabledNodeTypeValues(contentTypeId: string, fieldId: string, valueMappingFunction: ValueMappingFunction<RichTextNodeType>): Promise<void>;
+
+  addNodeContentTypeValues(contentTypeId: string, fieldId: string, nodeType: RichTextLinkedNodeType, values: string | string[]): Promise<void>;
+  removeNodeContentTypeValues(contentTypeId: string, fieldId: string, nodeType: RichTextLinkedNodeType, values: string | string[]): Promise<void>;
+  modifyNodeContentTypeValues(contentTypeId: string, fieldId: string, nodeType: RichTextLinkedNodeType, valueMappingFunction: ValueMappingFunction): Promise<void>;
+}
+
 export interface ValidationHelpers {
   addLinkContentTypeValues(contentTypeId: string, fieldId: string, values: string | string[]): Promise<void>;
-  addInValues(contentTypeId: string, fieldId: string, values: string | string[], options?: AddValuesOptions): Promise<void>;
   removeLinkContentTypeValues(contentTypeId: string, fieldId: string, values: string | string[]): Promise<void>;
-  removeInValues(contentTypeId: string, fieldId: string, values: string | string[]): Promise<void>;
   modifyLinkContentTypeValues(contentTypeId: string, fieldId: string, valueMappingFunction: ValueMappingFunction): Promise<void>;
+
+  addInValues(contentTypeId: string, fieldId: string, values: string | string[], options?: AddValuesOptions): Promise<void>;
+  removeInValues(contentTypeId: string, fieldId: string, values: string | string[]): Promise<void>;
   modifyInValues(contentTypeId: string, fieldId: string, valueMappingFunction: ValueMappingFunction): Promise<void>;
+
+  richText: RichTextValidationHelpers;
 }
 
 export function getValidationHelpers(migration: Migration, context: MigrationContext): ValidationHelpers;

package/lib/helpers/validation.js

@@ -27,26 +27,57 @@ const getValidationHelpers = (migration, context) => {
   const removeValidationValues = (existingValues, newValues = []) =>
     existingValues.filter((x) => !newValues.includes(x));
 
-  const modifyValidations = (validations, method, key, values) =>
-    validations.map((validation) => {
-      if (validation?.[key]) {
-        if (!Array.isArray(values)) {
-          values = [values];
+  /**
+   * Ensure the complete key path is available.
+   * If more than two keys are given the first node is treated as an Object.
+   * Return the container node, which should be an array.
+   * @param root {Object} The root container (the validations array)
+   * @param keyPath {string[]} The names of the nodes that must exist
+   * @return {Array} A tuple with the container object and the last key.
+   */
+  const ensureObjectPath = (root, keyPath) => {
+    let container = undefined;
+    let node = root;
+    keyPath.forEach((key, index) => {
+      container = node;
+      const isObjectNode = keyPath.length > 2 && index === 0;
+      if (Array.isArray(node)) {
+        let entry = node.find((someEntry) => someEntry[key]);
+        if (!entry) {
+          entry = { [key]: isObjectNode ? {} : [] };
+          node.push(entry);
         }
-        if (!Array.isArray(validation[key])) {
-          throw new Error(
-            `modifying validation properties is only supported on arrays. validation.${key} is typeof ${typeof validation[
-              key
-            ]}`
-          );
+        container = entry;
+        node = entry[key];
+      } else {
+        if (!node[key]) {
+          node[key] = isObjectNode ? {} : [];
         }
-        validation[key] = method(validation[key], values);
+        node = node[key];
       }
-
-      return validation;
     });
+    return [container, keyPath[keyPath.length - 1]];
+  };
+
+  /**
+   * Modify a validation property.
+   * @param {string[]} validations The list of validation entries
+   * @param {function} method The modification function
+   * @param {string[]} keyPaths The key paths where the first is the id of the validation root.
+   * @param {string | string[]} values
+   * @returns {*}
+   */
+  const modifyValidations = (validations, method, keyPaths, values) => {
+    const [containerObject, validationKey] = ensureObjectPath(validations, keyPaths);
+
+    containerObject[validationKey] = method(containerObject[validationKey], values);
+
+    return validations;
+  };
+
+  const modifyValidationValuesForType = async (validationKeyPaths, method, contentTypeId, fieldId, valueOrValues) => {
+    const values = Array.isArray(valueOrValues) ? valueOrValues : [valueOrValues];
 
-  const modifyValidationValuesForType = async (validationKey, method, contentTypeId, fieldId, values) => {
     // Fetch content type
     const { fields } = await makeRequest({
       method: 'GET',
@@ -62,11 +93,11 @@ const getValidationHelpers = (migration, context) => {
       const ct = migration.editContentType(contentTypeId);
       ct.editField(fieldId).items({
         ...items,
-        validations: modifyValidations(items?.validations, method, validationKey, values),
+        validations: modifyValidations(items?.validations || [], method, validationKeyPaths, values),
       });
     } else {
       const ct = migration.editContentType(contentTypeId);
-      ct.editField(fieldId).validations(modifyValidations(validations, method, validationKey, values));
+      ct.editField(fieldId).validations(modifyValidations(validations, method, validationKeyPaths, values));
     }
   };
 
@@ -75,7 +106,7 @@ const getValidationHelpers = (migration, context) => {
      * Add the specified values to the list of allowed content type values
      */
     async addLinkContentTypeValues(contentTypeId, fieldId, values) {
-      await modifyValidationValuesForType('linkContentType', addValidationValues, contentTypeId, fieldId, values);
+      await modifyValidationValuesForType(['linkContentType'], addValidationValues, contentTypeId, fieldId, values);
     },
 
     /**
@@ -85,21 +116,21 @@ const getValidationHelpers = (migration, context) => {
      */
     async addInValues(contentTypeId, fieldId, values, options = {}) {
       const addValuesWithOptions = (existingValues, newValues = []) => addValues(existingValues, newValues, options);
-      await modifyValidationValuesForType('in', addValuesWithOptions, contentTypeId, fieldId, values);
+      await modifyValidationValuesForType(['in'], addValuesWithOptions, contentTypeId, fieldId, values);
     },
 
     /**
      * Remove the specified values from the list of allowed content type values
      */
     async removeLinkContentTypeValues(contentTypeId, fieldId, values) {
-      await modifyValidationValuesForType('linkContentType', removeValidationValues, contentTypeId, fieldId, values);
+      await modifyValidationValuesForType(['linkContentType'], removeValidationValues, contentTypeId, fieldId, values);
     },
 
     /**
      * Remove the specified values from the list of allowed values
      */
     async removeInValues(contentTypeId, fieldId, values) {
-      await modifyValidationValuesForType('in', removeValidationValues, contentTypeId, fieldId, values);
+      await modifyValidationValuesForType(['in'], removeValidationValues, contentTypeId, fieldId, values);
     },
 
     /**
@@ -108,7 +139,7 @@ const getValidationHelpers = (migration, context) => {
      */
     async modifyLinkContentTypeValues(contentTypeId, fieldId, valueMappingFunction) {
       const uniqueMappingFunction = (values) => unique(valueMappingFunction(values));
-      await modifyValidationValuesForType('linkContentType', uniqueMappingFunction, contentTypeId, fieldId, []);
+      await modifyValidationValuesForType(['linkContentType'], uniqueMappingFunction, contentTypeId, fieldId, []);
     },
 
     /**
@@ -117,7 +148,66 @@ const getValidationHelpers = (migration, context) => {
      */
     async modifyInValues(contentTypeId, fieldId, valueMappingFunction) {
       const uniqueMappingFunction = (values) => unique(valueMappingFunction(values));
-      await modifyValidationValuesForType('in', uniqueMappingFunction, contentTypeId, fieldId, []);
+      await modifyValidationValuesForType(['in'], uniqueMappingFunction, contentTypeId, fieldId, []);
+    },
+
+    richText: {
+      async addEnabledMarksValues(contentTypeId, fieldId, values) {
+        await modifyValidationValuesForType(['enabledMarks'], addValidationValues, contentTypeId, fieldId, values);
+      },
+      async removeEnabledMarksValues(contentTypeId, fieldId, values) {
+        await modifyValidationValuesForType(['enabledMarks'], removeValidationValues, contentTypeId, fieldId, values);
+      },
+      async modifyEnabledMarksValues(contentTypeId, fieldId, valueMappingFunction) {
+        const uniqueMappingFunction = (values) => unique(valueMappingFunction(values));
+        await modifyValidationValuesForType(['enabledMarks'], uniqueMappingFunction, contentTypeId, fieldId, []);
+      },
+
+      async addEnabledNodeTypeValues(contentTypeId, fieldId, values) {
+        await modifyValidationValuesForType(['enabledNodeTypes'], addValidationValues, contentTypeId, fieldId, values);
+      },
+      async removeEnabledNodeTypeValues(contentTypeId, fieldId, values) {
+        await modifyValidationValuesForType(
+          ['enabledNodeTypes'],
+          removeValidationValues,
+          contentTypeId,
+          fieldId,
+          values
+        );
+      },
+      async modifyEnabledNodeTypeValues(contentTypeId, fieldId, valueMappingFunction) {
+        const uniqueMappingFunction = (values) => unique(valueMappingFunction(values));
+        await modifyValidationValuesForType(['enabledNodeTypes'], uniqueMappingFunction, contentTypeId, fieldId, []);
+      },
+
+      async addNodeContentTypeValues(contentTypeId, fieldId, nodeType, values) {
+        await modifyValidationValuesForType(
+          ['nodes', nodeType, 'linkContentType'],
+          addValidationValues,
+          contentTypeId,
+          fieldId,
+          values
+        );
+      },
+      async removeNodeContentTypeValues(contentTypeId, fieldId, nodeType, values) {
+        await modifyValidationValuesForType(
+          ['nodes', nodeType, 'linkContentType'],
+          removeValidationValues,
+          contentTypeId,
+          fieldId,
+          values
+        );
+      },
+      async modifyNodeContentTypeValues(contentTypeId, fieldId, nodeType, valueMappingFunction) {
+        const uniqueMappingFunction = (values) => unique(valueMappingFunction(values));
+        await modifyValidationValuesForType(
+          ['nodes', nodeType, 'linkContentType'],
+          uniqueMappingFunction,
+          contentTypeId,
+          fieldId,
+          []
+        );
+      },
     },
   };
 };