@jungvonmatt/contentful-migrations 5.6.2 → 6.0.0

package/README.md

@@ -28,23 +28,26 @@ This initializes migrations and stores the config values in the `package.json` o
 
 The default configuration file name is `.migrationsrc`. But since we use [cosmiconfig](https://github.com/davidtheclark/cosmiconfig#cosmiconfig) you can also use the other supported config file formats and name patterns like `migrationsrc.json` or `migrations.config.js`.
 
-You can also use any config file path by adding the `-f <path/to/confg>` or `--config-file <path/to/config>` command line argument. The extensions `.json`, `.yaml`, `.yml`, `.js`, or `.cjs` are supported.
+You can also use any config file path by adding the `-f <path/to/confg>` or `--config-file <path/to/config>` command line argument. The extensions `.json`, `.yaml`, `.yml`, `.js`, `.ts`, `.mjs`, or `.cjs` are supported.
 
 By specifying the config file path you can use multiple config files for different environments or spaces in your project.
 
 #### Configuration values
 
-| Name                   | Default                   | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
-| ---------------------- |---------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| accessToken            | `undefined`               | Contentful Management Token. Just run `npx contentful login` and you're done.                                                                                                                                                                                                                                                                                                                                                                                                        |
-| spaceId                | `undefined`               | Contentful Space id. Will fallback to `process.env.CONTENTFUL_SPACE_ID` if not set.                                                                                                                                                                                                                                                                                                                                                                                                  |
-| environmentId          | `undefined`               | Contentful Environment id. Will fallback to `process.env.CONTENTFUL_ENVIRONMENT_ID` if not set.<br/>If neither `environmentId` nor `CONTENTFUL_ENVIRONMENT_ID` is available we search for environment whose id matches the current git branch                                                                                                                                                                                                                                        |
-| host                   | `undefined`               | Allows configuring the Contentful CLI for EU usage. Will fallback to the global contentful config in your `.contentfulrc.json` |
-| requestBatchSize       | `undefined`               | The batch size used for loading data from contentful. Contentful uses a default of 100. Use a smaller value when you get `Response size too big` errors (for example caused by very large rich text fields). Be aware that contentful migrations might hide the response size error and only print `The provided space does not exist or you do not have access`                                                                                                                     |
-| storage                | `undefined`               | We need to keep a hint to the executed migrations inside Contentful. You can choose between **content* and **tag**. <br/><br/>**Content** will add a new content type to your Contentful environment and stores the state of every migration as content entry (recommended approach) <br/>**tag** Will only store the latest version inside a tag. You need to preserve the right order yourself. When you add a new migration with an older version number it will not be executed. |
-| fieldId                | `'migration'`             | Id of the tag where the migration version is stored (only used with storage `tag`)                                                                                                                                                                                                                                                                                                                                                                                                   |
-| migrationContentTypeId | `'contentful-migrations'` | Id of the migration content-type (only used with storage `content`)                                                                                                                                                                                                                                                                                                                                                                                                                  |
-| directory              | `'./migrations'`          | Directory where the migration files are stored                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+All configuration values can also be set via environment variables
+
+| Name                   | Environment Variable                       | Default                   | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| ---------------------- | ------------------------------------------ | ------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| managementToken        | `CONTENTFUL_MANAGEMENT_TOKEN`              | `undefined`               | Contentful Management Token. Just run `npx contentful login` and you're done.                                                                                                                                                                                                                                                                                                                                                                                                           |
+| -accessToken-          |                                            | `undefined`               | Not supported anymore. Please use `managementToken` instead.                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| spaceId                | `CONTENTFUL_SPACE_ID`                      | `undefined`               | Contentful Space id. Will fallback to `process.env.CONTENTFUL_SPACE_ID` if not set.                                                                                                                                                                                                                                                                                                                                                                                                     |
+| environmentId          | `CONTENTFUL_ENVIRONMENT_ID`                | `undefined`               | Contentful Environment id. Will fallback to `process.env.CONTENTFUL_ENVIRONMENT_ID` if not set.<br/>If neither `environmentId` nor `CONTENTFUL_ENVIRONMENT_ID` is available we search for environment whose id matches the current git branch                                                                                                                                                                                                                                           |
+| host                   | `CONTENTFUL_HOST`                          | `undefined`               | Allows configuring the Contentful CLI for EU usage. Will fallback to the global contentful config in your `.contentfulrc.json`                                                                                                                                                                                                                                                                                                                                                          |
+| requestBatchSize       | `CONTENTFUL_MIGRATIONS_REQUEST_BATCH_SIZE` | `undefined`               | The batch size used for loading data from contentful. Contentful uses a default of 100. Use a smaller value when you get `Response size too big` errors (for example caused by very large rich text fields). Be aware that contentful migrations might hide the response size error and only print `The provided space does not exist or you do not have access`                                                                                                                        |
+| storage                | `CONTENTFUL_MIGRATIONS_STORAGE`            | `undefined`               | We need to keep a hint to the executed migrations inside Contentful. You can choose between **content\* and **tag**. <br/><br/>**Content** will add a new content type to your Contentful environment and stores the state of every migration as content entry (recommended approach) <br/>**tag\*\* Will only store the latest version inside a tag. You need to preserve the right order yourself. When you add a new migration with an older version number it will not be executed. |
+| fieldId                | `'CONTENTFUL_MIGRATIONS_FIELD_ID'`         | `'migration'`             | Id of the tag where the migration version is stored (only used with storage `tag`)                                                                                                                                                                                                                                                                                                                                                                                                      |
+| migrationContentTypeId | `CONTENTFUL_MIGRATIONS_CONTENT_TYPE_ID`    | `'contentful-migrations'` | Id of the migration content-type (only used with storage `content`)                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| directory              | `CONTENTFUL_MIGRATIONS_DIRECTORY`          | `'./migrations'`          | Directory where the migration files are stored                                                                                                                                                                                                                                                                                                                                                                                                                                          |
 
 <br/>
 <br/>
@@ -87,7 +90,7 @@ npx migrations generate
 
 Sometimes you may not want to start a migration from scratch. You can create a new Content type in the [contentful web app](https://www.contentful.com/help/content-modelling-basics/) and import it using the `fetch` command.
 
-*When you want to use the contentful web app to configure your content types you should do so in a separate environment because the migration will fail if the content-type is already present at the time you run the migration script*
+_When you want to use the contentful web app to configure your content types you should do so in a separate environment because the migration will fail if the content-type is already present at the time you run the migration script_
 
 ```bash
 # Generate migration scripts for all content types from the current environment
@@ -127,7 +130,7 @@ npx migrations execute <path/to/migration.js> -e <environment-id>
 ## Managing the migration versions stored in contentful
 
 Sometimes you may need to manually mark a migration as migrated or not. You can use the `version` command for this.
-*Use caution when using the version command. If you delete a version from the table and then run the migrate command, that migration version will be executed again.*
+_Use caution when using the version command. If you delete a version from the table and then run the migrate command, that migration version will be executed again._
 
 **This command is only available when using the content storage**
 
@@ -178,8 +181,8 @@ npx migrations doc -e <environment> -p <path/to/docs>
 `--template`: Use a custom template for docs. `.js` with default export or `.mustache` is allowed<br/>
 `--extension`: Use a custom file extension (default is `.md`)<br/>
 
-
 ## Migration helpers
+
 We provide you with a few smaller migration helpers. There aren't many at the moment, but there may be more in the future.
 
 To use the helpers you just need to wrap your migration with the provided `withHelpers` function which makes the helpers available as 3rd parameter
@@ -205,7 +208,7 @@ module.exports = withHelpers(async (migration, context, helpers) => {
 
   // Add or remove values from "in" validations without knowing all the other elements in the array
   await helpers.validation.addInValues('contentTypeId', 'fieldId', ['value']); // add at the end
-  await helpers.validation.addInValues('contentTypeId', 'fieldId', ['value'], { mode: 'sorted'}); // add and sort
+  await helpers.validation.addInValues('contentTypeId', 'fieldId', ['value'], { mode: 'sorted' }); // add and sort
   await helpers.validation.removeInValues('contentTypeId', 'fieldId', ['value']);
   await helpers.validation.modifyInValues('contentTypeId', 'fieldId', (existing) => {
     const result = existing.filter((value) => value.startsWith('prefix')); // keep values with prefix
@@ -213,6 +216,37 @@ module.exports = withHelpers(async (migration, context, helpers) => {
     return result; // possible duplicate values are removed afterwards
   });
 
+  // Add or remove enabled marks for a rich text field without knowing all the active marks
+  // See: https://github.com/contentful/rich-text/blob/master/packages/rich-text-types/src/marks.ts
+  await helpers.validation.richText.addEnabledMarksValues('contentTypeId', 'fieldId', ['bold']);
+  await helpers.validation.richText.removeEnabledMarksValues('contentTypeId', 'fieldId', ['underline']);
+  await helpers.validation.richText.modifyEnabledMarksValues('contentTypeId', 'fieldId', (existing) => {
+    const result = existing.filter((value) => value !== 'code'); // keep values with prefix
+    result.push('italic'); // and add one
+    return result; // possible duplicate values are removed afterwards
+  });
+
+  // Add or remove enabled node types for a rich text field without knowing all the active node types
+  // See https://github.com/contentful/rich-text/blob/master/packages/rich-text-types/src/blocks.ts
+  // and https://github.com/contentful/rich-text/blob/master/packages/rich-text-types/src/inlines.ts
+  await helpers.validation.richText.addEnabledNodeTypeValues('contentTypeId', 'fieldId', ['blockquote']);
+  await helpers.validation.richText.removeEnabledNodeTypeValues('contentTypeId', 'fieldId', ['hyperlink']);
+  await helpers.validation.richText.modifyEnabledNodeTypeValues('contentTypeId', 'fieldId', (existing) => {
+    const result = existing.filter((value) => !value.startsWith('heading-')); // filter out headings like 'heading-1'
+    result.push('quote'); // and add one
+    return result; // possible duplicate values are removed afterwards
+  });
+
+  // Add or remove embedded or linked content types for a rich text field without knowing all the allowed content types
+  // The possible node types are 'entry-hyperlink', 'embedded-entry-block' and 'embedded-entry-inline'.
+  await helpers.validation.richText.addNodeContentTypeValues('contentTypeId', 'fieldId', 'embedded-entry-block', ['a-content-type']);
+  await helpers.validation.richText.removeNodeContentTypeValues('contentTypeId', 'fieldId', 'embedded-entry-inline', ['a-content-type']);
+  await helpers.validation.richText.modifyNodeContentTypeValues('contentTypeId', 'fieldId', 'entry-hyperlink', (existing) => {
+    const result = existing.filter((value) => value.startsWith('t-')); // filter out content types that not start with 't-'
+    result.push('t-article'); // and add one
+    return result; // possible duplicate values are removed afterwards
+  });
+
 });
 ```
 
@@ -222,11 +256,10 @@ Of course. We appreciate all of our [contributors](https://github.com/jungvonmat
 welcome contributions to improve the project further. If you're uncertain whether an addition should be made, feel
 free to open up an issue and we can discuss it.
 
-
-
 ## Contributors
+
 <a href="https://github.com/jungvonmatt/contentful-migrations/graphs/contributors">
-  <img src="https://contrib.rocks/image?repo=jungvonmatt/contentful-migrations" />
+  <img alt="Contributor profile pictures" src="https://contrib.rocks/image?repo=jungvonmatt/contentful-migrations" />
 </a>
 
 [npm-url]: https://www.npmjs.com/package/@jungvonmatt/contentful-migrations

package/cli.js

@@ -13,7 +13,7 @@ const { versionDelete, versionAdd } = require('./lib/version');
 const { transferContent } = require('./lib/content');
 const { createOfflineDocs } = require('./lib/doc');
 const { createEnvironment, removeEnvironment, resetEnvironment } = require('./lib/environment');
-const { getConfig, askAll, askMissing, STORAGE_CONTENT, STORAGE_TAG } = require('./lib/config');
+const { getConfig, confirm, STORAGE_CONTENT, STORAGE_TAG } = require('./lib/config');
 const pkg = require('./package.json');
 
 require('dotenv').config();
@@ -23,7 +23,7 @@ const parseArgs = (cmd) => {
   const directory = cmd.path || parent.path;
   return {
     ...cmd,
-    configFile: cmd.configFile,
+    configFile: cmd.config,
     environment: cmd.env || parent.env,
     directory: directory ? path.resolve(directory) : undefined,
     sourceEnvironmentId: cmd.sourceEnvironmentId || parent.sourceEnvironmentId,
@@ -59,37 +59,52 @@ const program = new Command();
 program.version(pkg.version);
 program
   .command('init')
+  .option('-s, --space-id <space-id>', 'Contentful space id')
   .option('--host <host>', 'Management API host')
+  .option('--config <path/to/config>', 'Config file path (disables auto detect)')
+  .option('--cwd <directory>', 'Working directory. Defaults to process.cwd()')
   .description('Initialize contentful-migrations')
   .action(
     actionRunner(async (cmd) => {
-      const config = await getConfig(parseArgs(cmd || {}));
-      const verified = await askAll(config);
-      const { managementToken, accessToken, environmentId, spaceId, ...rest } = verified;
+      const config = await getConfig(parseArgs(cmd || {}), [
+        'managementToken',
+        'spaceId',
+        'environmentId',
+        'storage',
+        'fieldId',
+        'migrationContentTypeId',
+        'directory',
+      ]);
+
+      const { managementToken, accessToken, environmentId, spaceId, ...rest } = config;
 
-      if (verified.storage === STORAGE_CONTENT) {
-        await initializeContentModel({ ...config, ...verified });
-        await migrateToContentStorage({ ...config, ...verified });
+      if (config.storage === STORAGE_CONTENT) {
+        await initializeContentModel(config);
+        await migrateToContentStorage(config);
       }
-      if (verified.storage === STORAGE_TAG) {
-        await migrateToTagStorage({ ...config, ...verified });
+      if (config.storage === STORAGE_TAG) {
+        await migrateToTagStorage(config);
       }
 
       if (!process.env.CONTENTFUL_SPACE_ID) {
         rest.spaceId = spaceId;
       }
 
-      // try to store in package.json
-      const { pkgUp } = await import('pkg-up');
-      const localPkg = await pkgUp();
-      if (localPkg) {
-        const packageJson = await fs.readJson(localPkg);
-        rest.directory = path.relative(path.dirname(localPkg), rest.directory);
-        packageJson.migrations = rest;
-        await fs.outputJson(localPkg, packageJson, { spaces: 2 });
-      } else {
-        // store in .migrationsrc if no package.json is available
-        await fs.outputJson(path.join(process.cwd(), '.migrationsrc'), rest, { spaces: 2 });
+      const storeConfig = await confirm({ message: 'Do you want to store the configuration?' });
+
+      if (storeConfig) {
+        // try to store in package.json
+        const { pkgUp } = await import('pkg-up');
+        const localPkg = await pkgUp();
+        if (localPkg) {
+          const packageJson = await fs.readJson(localPkg);
+          rest.directory = path.relative(path.dirname(localPkg), rest.directory);
+          packageJson.migrations = rest;
+          await fs.outputJson(localPkg, packageJson, { spaces: 2 });
+        } else {
+          // store in .migrationsrc if no package.json is available
+          await fs.outputJson(path.join(process.cwd(), '.migrationsrc'), rest, { spaces: 2 });
+        }
       }
     })
   );
@@ -103,12 +118,17 @@ program
   .option('-v, --verbose', 'Verbosity')
   .option('--host <host>', 'Management API host')
   .option('--config <path/to/config>', 'Config file path (disables auto detect)')
+  .option('--cwd <directory>', 'Working directory. Defaults to process.cwd()')
   .description('Generate a new Contentful migration from content type')
   .action(
     actionRunner(async (cmd) => {
-      const config = await getConfig(parseArgs(cmd || {}));
-      const verified = await askMissing(config);
-      await fetchMigration({ ...verified, contentType: cmd.contentType });
+      const config = await getConfig(parseArgs(cmd || {}), [
+        'managementToken',
+        'spaceId',
+        'environmentId',
+        'directory',
+      ]);
+      await fetchMigration({ ...config, contentType: cmd.contentType });
     })
   );
 
@@ -120,12 +140,17 @@ program
   .option('-v, --verbose', 'Verbosity')
   .option('--host <host>', 'Management API host')
   .option('--config <path/to/config>', 'Config file path (disables auto detect)')
+  .option('--cwd <directory>', 'Working directory. Defaults to process.cwd()')
   .description('Generate a new Contentful migration')
   .action(
     actionRunner(async (cmd) => {
-      const config = await getConfig(parseArgs(cmd || {}));
-      const verified = await askMissing(config);
-      await createMigration(verified);
+      const config = await getConfig(parseArgs(cmd || {}), [
+        'managementToken',
+        'spaceId',
+        'environmentId',
+        'directory',
+      ]);
+      await createMigration(config);
     })
   );
 
@@ -138,21 +163,29 @@ program
   .option('-y, --yes', 'Assume "yes" as answer to all prompts and run non-interactively.')
   .option('--host <host>', 'Management API host')
   .option('--config <path/to/config>', 'Config file path (disables auto detect)')
+  .option('--cwd <directory>', 'Working directory. Defaults to process.cwd()')
   .option('--bail', 'Abort execution after first failed migration (default: true)', true)
   .option('--no-bail', 'Ignore failed migrations')
   .description('Execute all unexecuted migrations available.')
   .action(
     actionRunner(async (cmd) => {
-      const config = await getConfig(parseArgs(cmd || {}));
-      const verified = await askMissing(config);
+      const config = await getConfig(parseArgs(cmd || {}), [
+        'managementToken',
+        'spaceId',
+        'environmentId',
+        'storage',
+        'fieldId',
+        'migrationContentTypeId',
+        'directory',
+      ]);
 
-      const { missingStorageModel } = verified;
+      const { missingStorageModel } = config;
       if (missingStorageModel) {
         console.error(pc.red('\nError:'), `Missing migration content type. Run ${pc.cyan('npx migrations init')}`);
         process.exit(1);
       }
 
-      await runMigrations(verified);
+      await runMigrations(config);
     }, false)
   );
 
@@ -164,19 +197,26 @@ program
   .option('-y, --yes', 'Assume "yes" as answer to all prompts and run non-interactively.')
   .option('--host <host>', 'Management API host')
   .option('--config <path/to/config>', 'Config file path (disables auto detect)')
+  .option('--cwd <directory>', 'Working directory. Defaults to process.cwd()')
   .description('Execute a single migration.')
   .action(
     actionRunner(async (file, options) => {
-      const config = await getConfig(parseArgs(options || {}));
-      const verified = await askMissing(config);
+      const config = await getConfig(parseArgs(cmd || {}), [
+        'managementToken',
+        'spaceId',
+        'environmentId',
+        'storage',
+        'fieldId',
+        'migrationContentTypeId',
+        'directory',
+      ]);
 
-      const { missingStorageModel } = verified;
+      const { missingStorageModel } = config;
       if (missingStorageModel) {
         console.error(pc.red('\nError:'), `Missing migration content type. Run ${pc.cyan('npx migrations init')}`);
         process.exit(1);
       }
-
-      await executeMigration(path.resolve(file), verified);
+      await executeMigration(path.resolve(file), config);
     }, false)
   );
 
@@ -189,27 +229,35 @@ program
   .option('--config <path/to/config>', 'Config file path (disables auto detect)')
   .option('--add', 'Mark migration as migrated')
   .option('--remove', 'Delete migration entry in Contentful')
+  .option('--cwd <directory>', 'Working directory. Defaults to process.cwd()')
   .description('Manually mark a migration as migrated or not. (Only available with the Content-model storage)')
   .action(
     actionRunner(async (file, options) => {
       const { remove, add } = options;
-      const config = await getConfig(parseArgs(options || {}));
-      const verified = await askMissing(config);
+      const config = await getConfig(parseArgs(cmd || {}), [
+        'managementToken',
+        'spaceId',
+        'environmentId',
+        'storage',
+        'fieldId',
+        'migrationContentTypeId',
+        'directory',
+      ]);
 
-      const { missingStorageModel } = verified;
+      const { missingStorageModel } = config;
       if (missingStorageModel) {
         console.error(pc.red('\nError:'), `Missing migration content type. Run ${pc.cyan('npx migrations init')}`);
         process.exit(1);
       }
 
-      const { storage } = verified || {};
+      const { storage } = config || {};
       if (storage === STORAGE_TAG) {
         throw new Error('The version command is not available for the "tag" storage');
       }
       if (remove) {
-        await versionDelete(file, verified);
+        await versionDelete(file, config);
       } else if (add) {
-        await versionAdd(file, verified);
+        await versionAdd(file, config);
       }
     }, true)
   );
@@ -224,23 +272,27 @@ program
   .option('--remove', 'Delete contentful environment')
   .option('--reset', 'Reset contentful environment')
   .option('--source-environment-id <environment-id>', 'Set the source environment to clone new environment from')
+  .option('--cwd <directory>', 'Working directory. Defaults to process.cwd()')
   .description('Add or remove a contentful environment for migrations')
   .action(
     actionRunner(async (environmentId, options) => {
       const { remove, create, reset } = options;
-      const config = await getConfig(parseArgs({ ...(options || {}), environmentId }));
-      const verified = await askMissing(config, ['accessToken', 'spaceId', 'environmentId']);
+      const config = await getConfig(parseArgs({ ...(options || {}), environmentId }), [
+        'managementToken',
+        'spaceId',
+        'environmentId',
+      ]);
 
       if (create) {
-        return createEnvironment(environmentId, verified);
+        return createEnvironment(environmentId, config);
       }
 
       if (remove) {
-        return removeEnvironment(environmentId, verified);
+        return removeEnvironment(environmentId, config);
       }
 
       if (reset) {
-        return resetEnvironment(environmentId, verified);
+        return resetEnvironment(environmentId, config);
       }
     }, true)
   );
@@ -255,12 +307,12 @@ program
   .option('--host <host>', 'Management API host')
   .option('--config <path/to/config>', 'Config file path (disables auto detect)')
   .option('--extension <file-extension>', 'Use custom file extension (default is `md`)')
+  .option('--cwd <directory>', 'Working directory. Defaults to process.cwd()')
   .description('Generate offline docs from content-types')
   .action(
     actionRunner(async (cmd) => {
-      const config = await getConfig(parseArgs(cmd || {}));
-      const verified = await askMissing(config, ['accessToken', 'spaceId', 'environmentId']);
-      await createOfflineDocs(verified);
+      const config = await getConfig(parseArgs(cmd || {}), ['managementToken', 'spaceId', 'environmentId']);
+      await createOfflineDocs(config);
     }, true)
   );
 
@@ -277,14 +329,14 @@ program
   .option('--diff', 'Manually choose skip/overwrite for every conflict')
   .option('--force', 'No manual diffing. Overwrites all conflicting entries/assets')
   .description('Transfer content from source environment to destination environment')
+  .option('--cwd <directory>', 'Working directory. Defaults to process.cwd()')
   .action(
     actionRunner(async (cmd) => {
-      const config = await getConfig(parseArgs(cmd || {}));
-      const verified = await askMissing({ ...config, environmentId: 'not-used' });
+      const config = await getConfig(parseArgs(cmd || {}), ['managementToken', 'spaceId', 'storage']);
 
       // run migrations on destination environment
       await transferContent({
-        ...verified,
+        ...config,
         contentType: cmd.contentType || '',
         forceOverwrite: cmd.force || false,
         diffConflicts: cmd.diff || false,

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,102 +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,
-    host: process.env.CONTENTFUL_HOST,
-  };
-
-  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: [
@@ -123,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,
+          []
+        );
+      },
     },
   };
 };

package/lib/helpers/validation.test.js

@@ -6,7 +6,6 @@ describe('getValidationHelpers', () => {
       {
         id: 'selectWithOtherValidationProps',
         type: 'Text',
-        items: [],
         validations: [
           {
             foo: 'test',
@@ -20,7 +19,6 @@ describe('getValidationHelpers', () => {
       {
         id: 'select',
         type: 'Text',
-        items: [],
         validations: [
           {
             in: ['foo', 'bar', 'baz'],
@@ -36,11 +34,51 @@ describe('getValidationHelpers', () => {
           },
         ],
       },
+      {
+        id: 'string',
+        type: 'Text',
+      },
       {
         id: 'string-array',
         type: 'Array',
         items: [],
       },
+      {
+        id: 'richTextNoValidations',
+        type: 'RichText',
+      },
+      {
+        id: 'richTextFullValidations',
+        type: 'RichText',
+        validations: [
+          {
+            enabledMarks: ['bold', 'italic'],
+          },
+          {
+            enabledNodeTypes: [
+              'blockquote',
+              'embedded-entry-block',
+              'hyperlink',
+              'entry-hyperlink',
+              'embedded-entry-inline',
+            ],
+          },
+          {
+            nodes: {
+              'embedded-entry-block': [
+                {
+                  linkContentType: ['foo', 'baz'],
+                },
+              ],
+              'embedded-entry-inline': [
+                {
+                  linkContentType: ['foo'],
+                },
+              ],
+            },
+          },
+        ],
+      },
     ],
   });
 
@@ -98,6 +136,16 @@ describe('getValidationHelpers', () => {
         },
       ]);
     });
+
+    it('should add values where none where defined', async () => {
+      const validations = getValidationHelpers(migration, context);
+      await validations.addInValues('some-content-type', 'string', 'foo');
+      expect(resultValidation).toEqual([
+        {
+          in: ['foo'],
+        },
+      ]);
+    });
   });
 
   describe('removeInValues', () => {
@@ -168,4 +216,166 @@ describe('getValidationHelpers', () => {
       ]);
     });
   });
+
+  describe('richText', () => {
+    describe('addEnabledMarksValue', () => {
+      it('should add values at the end', async () => {
+        const validations = getValidationHelpers(migration, context);
+        await validations.richText.addEnabledMarksValues('some-content-type', 'richTextFullValidations', 'code');
+        expect(resultValidation).toContainEqual({
+          enabledMarks: ['bold', 'italic', 'code'],
+        });
+      });
+    });
+
+    describe('removeEnabledMarksValue', () => {
+      it('should remove values', async () => {
+        const validations = getValidationHelpers(migration, context);
+        await validations.richText.removeEnabledMarksValues('some-content-type', 'richTextFullValidations', 'bold');
+        expect(resultValidation).toContainEqual({
+          enabledMarks: ['italic'],
+        });
+      });
+    });
+
+    describe('modifyEnabledMarksValue', () => {
+      it('should modify unique values with custom function', async () => {
+        const validations = getValidationHelpers(migration, context);
+        await validations.richText.modifyEnabledMarksValues(
+          'some-content-type',
+          'richTextFullValidations',
+          (values) => {
+            const result = values.slice(0, values.length - 1); // remove italic
+            result.push('code');
+            result.push('bold'); // should be removed since it exists
+            return result;
+          }
+        );
+        expect(resultValidation).toContainEqual({
+          enabledMarks: ['bold', 'code'],
+        });
+      });
+    });
+
+    describe('addEnabledNodeTypeValue', () => {
+      it('should add values at the end', async () => {
+        const validations = getValidationHelpers(migration, context);
+        await validations.richText.addEnabledNodeTypeValues('some-content-type', 'richTextFullValidations', 'hr');
+        expect(resultValidation).toContainEqual({
+          enabledNodeTypes: [
+            'blockquote',
+            'embedded-entry-block',
+            'hyperlink',
+            'entry-hyperlink',
+            'embedded-entry-inline',
+            'hr',
+          ],
+        });
+      });
+    });
+
+    describe('removeEnabledNodeTypeValue', () => {
+      it('should remove values', async () => {
+        const validations = getValidationHelpers(migration, context);
+        await validations.richText.removeEnabledNodeTypeValues(
+          'some-content-type',
+          'richTextFullValidations',
+          'blockquote'
+        );
+        expect(resultValidation).toContainEqual({
+          enabledNodeTypes: ['embedded-entry-block', 'hyperlink', 'entry-hyperlink', 'embedded-entry-inline'],
+        });
+      });
+    });
+
+    describe('modifyEnabledNodeTypeValue', () => {
+      it('should modify unique values with custom function', async () => {
+        const validations = getValidationHelpers(migration, context);
+        await validations.richText.modifyEnabledNodeTypeValues(
+          'some-content-type',
+          'richTextFullValidations',
+          (values) => {
+            const result = values.slice(0, values.length - 1); // remove embedded-entry-inline
+            result.push('hr');
+            result.push('blockquote'); // should be removed since it exists
+            return result;
+          }
+        );
+        expect(resultValidation).toContainEqual({
+          enabledNodeTypes: ['blockquote', 'embedded-entry-block', 'hyperlink', 'entry-hyperlink', 'hr'],
+        });
+      });
+    });
+
+    describe('addNodeContentTypeValues', () => {
+      it('should add values at the end', async () => {
+        const validations = getValidationHelpers(migration, context);
+        await validations.richText.addNodeContentTypeValues(
+          'some-content-type',
+          'richTextFullValidations',
+          'embedded-entry-block',
+          'bar'
+        );
+        expect(resultValidation.find((v) => v.nodes).nodes['embedded-entry-block']).toEqual([
+          {
+            linkContentType: ['foo', 'baz', 'bar'],
+          },
+        ]);
+      });
+
+      it('should add complete entry if not existing', async () => {
+        const validations = getValidationHelpers(migration, context);
+        await validations.richText.addNodeContentTypeValues(
+          'some-content-type',
+          'richTextFullValidations',
+          'entry-hyperlink',
+          'bar'
+        );
+        expect(resultValidation.find((v) => v.nodes).nodes['entry-hyperlink']).toEqual([
+          {
+            linkContentType: ['bar'],
+          },
+        ]);
+      });
+    });
+
+    describe('removeNodeContentTypeValues', () => {
+      it('should remove values', async () => {
+        const validations = getValidationHelpers(migration, context);
+        await validations.richText.removeNodeContentTypeValues(
+          'some-content-type',
+          'richTextFullValidations',
+          'embedded-entry-block',
+          'foo'
+        );
+        expect(resultValidation.find((v) => v.nodes).nodes['embedded-entry-block']).toEqual([
+          {
+            linkContentType: ['baz'],
+          },
+        ]);
+      });
+    });
+
+    describe('modifyNodeContentTypeValues', () => {
+      it('should modify unique values with custom function', async () => {
+        const validations = getValidationHelpers(migration, context);
+        await validations.richText.modifyNodeContentTypeValues(
+          'some-content-type',
+          'richTextFullValidations',
+          'embedded-entry-block',
+          (values) => {
+            const result = values.slice(0, values.length - 1); // remove foo
+            result.push('bar');
+            result.push('baz'); // should be removed since it exists
+            return result;
+          }
+        );
+        expect(resultValidation.find((v) => v.nodes).nodes['embedded-entry-block']).toEqual([
+          {
+            linkContentType: ['foo', 'bar', 'baz'],
+          },
+        ]);
+      });
+    });
+  });
 });

package/lib/migration.js

@@ -138,15 +138,15 @@ const fetchMigration = async (config) => {
  * @returns
  */
 const executeMigration = async (file, config) => {
-  const { accessToken, requestBatchSize, spaceId } = config || {};
+  const { managementToken, requestBatchSize, spaceId } = config || {};
   const client = await getEnvironment(config);
   const environmentId = client.sys.id;
   const name = path.basename(file);
   const [, version] = /^(\d+)-/.exec(name);
 
   const options = {
-    filePath: file,
-    accessToken,
+    filePath: path.resolve(file),
+    accessToken: managementToken,
     spaceId,
     environmentId,
     requestBatchSize,
@@ -154,7 +154,7 @@ const executeMigration = async (file, config) => {
   };
 
   if (config.host) {
-    options.host = config.host
+    options.host = config.host;
   }
 
   console.log(`\nRun migration ${pc.green(version)} in environment ${pc.green(environmentId)}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jungvonmatt/contentful-migrations",
-  "version": "5.6.2",
+  "version": "6.0.0",
   "description": "Helper to handle migrations in contentful",
   "main": "index.js",
   "files": [
@@ -26,7 +26,7 @@
   "author": "Ben Zörb <benjamin.zoerb@jvm.de>",
   "license": "MIT",
   "engines": {
-    "node": ">=14"
+    "node": ">=18"
   },
   "keywords": [
     "contentful",
@@ -35,6 +35,7 @@
   ],
   "dependencies": {
     "@contentful/rich-text-plain-text-renderer": "^15.12.1",
+    "@jungvonmatt/contentful-config": "^3.0.1",
     "array.prototype.flatmap": "^1.3.3",
     "ascii-tree": "^0.3.0",
     "cli-progress": "^3.11.2",
@@ -48,9 +49,9 @@
     "deep-diff": "^1.0.2",
     "diff": "^5.1.0",
     "dotenv": "^10.0.0",
+    "enquirer": "^2.4.1",
     "fs-extra": "^10.1.0",
     "globby": "^12.0.2",
-    "inquirer": "^8.2.0",
     "markdown-table": "^3.0.4",
     "merge-options": "^3.0.4",
     "mustache": "^4.2.0",