@jungvonmatt/contentful-migrations 5.2.2 → 5.3.0

package/README.md

@@ -184,13 +184,25 @@ module.exports = withHelpers(async (migration, context, helpers) => {
   // Get default locale
   await helpers.locale.getDefaultLocale();
 
-  // Add or remove values from "linkContentType" validations without affecting the other elements in the array
-  await helpers.validation.addLinkContentTypeValues('contentTypeId', 'fieldId', ['value']);
-  await helpers.validation.removeLinkContentTypeValues('contentTypeId', 'fieldId', ['value']);
-
-  // Add or remove values from "in" validations without affecting the other elements in the array
-  await helpers.validation.addInValues('contentTypeId', 'fieldId', ['value']);
+  // Add or remove values from "linkContentType" validations without knowing all the other elements in the array
+  await helpers.validation.addLinkContentTypeValues('contentTypeId', 'fieldId', ['some-content-type']);
+  await helpers.validation.removeLinkContentTypeValues('contentTypeId', 'fieldId', ['some-content-type']);
+  await helpers.validation.modifyLinkContentTypeValues('contentTypeId', 'fieldId', (existing) => {
+    const result = existing.filter((contentType) => !contentType.startsWith('a-')); // remove some by prefix
+    result.push('t-test'); // and add one
+    return result; // possible duplicate values are removed afterwards
+  });
+
+  // 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.removeInValues('contentTypeId', 'fieldId', ['value']);
+  await helpers.validation.modifyInValues('contentTypeId', 'fieldId', (existing) => {
+    const result = existing.filter((value) => value.startsWith('prefix')); // keep values with prefix
+    result.push('other'); // and add one
+    return result; // possible duplicate values are removed afterwards
+  });
+
 });
 ```
 

package/index.d.ts

@@ -1,4 +1,5 @@
-import type Migration, { MigrationContext, MigrationFunction } from "contentful-migration";
+import type Migration from "contentful-migration";
+import type { MigrationContext, MigrationFunction } from "contentful-migration";
 import type { LocaleHelpers } from "./lib/helpers/locale";
 import type { ValidationHelpers } from "./lib/helpers/validation";
 

package/index.js

@@ -11,16 +11,16 @@
  * });
  *
  */
- const { getValidationHelpers } = require('./lib/helpers/validation');
- const { getLocaleHelpers } = require('./lib/helpers/locale');
+const { getValidationHelpers } = require('./lib/helpers/validation');
+const { getLocaleHelpers } = require('./lib/helpers/locale');
 
- // Export wrapper
- module.exports.withHelpers = (cb) => (migration, context) => {
-   const locale = getLocaleHelpers(migration, context);
-   const validation = getValidationHelpers(migration, context);
+// Export wrapper
+module.exports.withHelpers = (cb) => (migration, context) => {
+  const locale = getLocaleHelpers(migration, context);
+  const validation = getValidationHelpers(migration, context);
 
-   return cb(migration, context, { locale, validation });
- };
+  return cb(migration, context, { locale, validation });
+};
 
- module.exports.getValidationHelpers = getValidationHelpers;
- module.exports.getLocaleHelpers = getLocaleHelpers;
+module.exports.getValidationHelpers = getValidationHelpers;
+module.exports.getLocaleHelpers = getLocaleHelpers;

package/lib/backend.js

@@ -2,7 +2,7 @@ const path = require('path');
 const fs = require('fs/promises');
 const chalk = require('chalk');
 const cliProgress = require('cli-progress');
-const { getEnvironment, getDefaultLocale } = require('./contentful');
+const { getEnvironment, getDefaultLocale, getMigrationItems } = require('./contentful');
 const { STORAGE_TAG, STORAGE_CONTENT, STATE_SUCCESS, STATE_FAILURE } = require('./config');
 
 /**
@@ -193,8 +193,8 @@ const migrateToContentStorage = async (config) => {
   const client = await getEnvironment(config);
   const version = await getMigrationVersionFromTag(config);
 
-  const {globby} = await import('globby');
-  const migrations = await globby([`${directory}/*.js`,`${directory}/*.cjs`]);
+  const { globby } = await import('globby');
+  const migrations = await globby([`${directory}/*.js`, `${directory}/*.cjs`]);
   const environmentId = client.sys.id;
   const filtered = migrations.filter((file) => {
     const name = path.basename(file);
@@ -292,9 +292,7 @@ const migrateToTagStorage = async (config) => {
  * @returns {number[]}
  */
 const getMigrationVersions = async (config) => {
-  const { migrationContentTypeId } = config;
-  const client = await getEnvironment(config);
-  const { items } = await client.getEntries({ content_type: migrationContentTypeId });
+  const items = await getMigrationItems(config);
 
   return (items || []).map((item) => parseInt(item.sys.id, 10));
 };
@@ -353,11 +351,11 @@ const getLatestVersion = async (config) => {
   return getMigrationVersionFromTag(config);
 };
 
-const getVersionFromFile = file => {
+const getVersionFromFile = (file) => {
   const name = path.basename(file);
   const [, num] = /^(\d+)-/.exec(name);
-  return parseInt(num,10);
-}
+  return parseInt(num, 10);
+};
 
 /**
  * Get all unexecuted migration files
@@ -365,17 +363,16 @@ const getVersionFromFile = file => {
  */
 const getNewMigrations = async (config) => {
   const { directory, storage, migrationContentTypeId } = config || {};
-  const {globby} = await import('globby');
-  const migrations = (await globby([`${directory}/*.js`,`${directory}/*.cjs`])).sort((a,b) => {
+  const { globby } = await import('globby');
+  const migrations = (await globby([`${directory}/*.js`, `${directory}/*.cjs`])).sort((a, b) => {
     const numA = getVersionFromFile(a);
     const numB = getVersionFromFile(b);
-    return numA-numB;
+    return numA - numB;
   });
 
   if (storage === STORAGE_CONTENT) {
     try {
       const versions = await getMigrationVersions(config);
-
       const result = migrations.filter((file) => {
         const num = getVersionFromFile(file);
         return !(versions || []).includes(num);
@@ -384,10 +381,14 @@ const getNewMigrations = async (config) => {
       return result;
     } catch (error) {
       // check if we have a migration scheduled which adds the initial content-type
-      const regexp = new RegExp(`createContentType\\(['"]${migrationContentTypeId}['"]\\)`,'mg');
-      const initial = (await Promise.all(migrations.map(async file => {
-        return fs.readFile(file, 'utf8');
-      }))).some(content => regexp.test(content));
+      const regexp = new RegExp(`createContentType\\(['"]${migrationContentTypeId}['"]\\)`, 'mg');
+      const initial = (
+        await Promise.all(
+          migrations.map(async (file) => {
+            return fs.readFile(file, 'utf8');
+          })
+        )
+      ).some((content) => regexp.test(content));
 
       if (initial) {
         return migrations;

package/lib/contentful.js

@@ -215,11 +215,9 @@ const pagedGet = async (environment, { method, skip = 0, aggregatedResponse = nu
   } else {
     aggregatedResponse.items = aggregatedResponse.items.concat(response.items);
   }
-  // const page = Math.ceil(skip / MAX_ALLOWED_LIMIT) + 1;
-  // const pages = Math.ceil(response.total / MAX_ALLOWED_LIMIT);
 
-  if (skip + MAX_ALLOWED_LIMIT <= response.total) {
-    return pagedGet(environment, { method, skip: skip + MAX_ALLOWED_LIMIT, aggregatedResponse, query });
+  if (skip + fullQuery.limit <= response.total) {
+    return pagedGet(environment, { method, skip: skip + fullQuery.limit, aggregatedResponse, query });
   }
   return aggregatedResponse;
 };
@@ -316,6 +314,17 @@ const getContent = async (options) => {
   return { entries, assets, contentTypes };
 };
 
+const getMigrationItems = async (options) => {
+  const { migrationContentTypeId } = options;
+  const environment = await getEnvironment(options);
+  const { items } = await pagedGet(environment, {
+    method: 'getEntries',
+    query: { content_type: migrationContentTypeId },
+  });
+
+  return items;
+};
+
 const getContentTypes = async (options) => {
   const { contentType } = options;
   const environment = await getEnvironment(options);
@@ -354,6 +363,7 @@ exports.getNodeName = getNodeName;
 exports.getEnvironmentId = getEnvironmentId;
 exports.getEditorInterfaces = getEditorInterfaces;
 exports.getApiKeys = getApiKeys;
+exports.getMigrationItems = getMigrationItems;
 
 // Constants
 exports.TYPE_SYMBOL = TYPE_SYMBOL;

package/lib/helpers/locale.d.ts

@@ -1,8 +1,9 @@
 import type { Locale } from "contentful-management/dist/typings/export-types";
-import type Migration, { MigrationContext } from "contentful-migration";
+import type Migration from "contentful-migration";
+import type { MigrationContext } from "contentful-migration";
 
 export interface LocaleHelpers {
-  getLocales(): Promise<[Locale]>;
+  getLocales(): Promise<Locale[]>;
   getDefaultLocale(): Promise<Locale>;
 }
 

package/lib/helpers/validation.d.ts

@@ -1,10 +1,22 @@
-import type Migration, { MigrationContext } from "contentful-migration";
+import type Migration from "contentful-migration";
+import type { MigrationContext } from "contentful-migration";
+
+export type ValueMappingFunction = (values: string[]) => string[];
+
+export type AddValuesOptionMode = 'sorted' | 'start' | 'end' | 'before' | 'after';
+
+export interface AddValuesOptions {
+  mode?: AddValuesOptionMode;
+  ref?: string;
+}
 
 export interface ValidationHelpers {
-  addLinkContentTypeValues(contentTypeId: string, fieldId: string, values: string | [string]): Promise<void>;
-  addInValues(contentTypeId: string, fieldId: string, values: string | [string]): Promise<void>;
-  removeLinkContentTypeValues(contentTypeId: string, fieldId: string, values: string | [string]): Promise<void>;
-  removeInValues(contentTypeId: string, fieldId: string, values: string | [string]): Promise<void>;
+  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>;
+  modifyInValues(contentTypeId: string, fieldId: string, valueMappingFunction: ValueMappingFunction): Promise<void>;
 }
 
 export function getValidationHelpers(migration: Migration, context: MigrationContext): ValidationHelpers;

package/lib/helpers/validation.js

@@ -1,4 +1,5 @@
-const { TYPE_LINK, TYPE_ARRAY } = require('../contentful');
+const { TYPE_ARRAY } = require('../contentful');
+const { addValues, unique } = require('./validation.utils');
 
 /**
  * Adds utils for the migration
@@ -10,9 +11,9 @@ const { TYPE_LINK, TYPE_ARRAY } = require('../contentful');
  *   const validationHelper = getValidationHelpers(migration, context);
  *   ...
  *
- *   await validationHelper.addLinkContentTypeValues('contentTypeId', 'fieldId', ['value']);
+ *   await validationHelper.addLinkContentTypeValues('contentTypeId', 'fieldId', ['some-content-type']);
  *   await validationHelper.addInValues('contentTypeId', 'fieldId', ['value']);
- *   await validationHelper.removeLinkContentTypeValues('contentTypeId', 'fieldId', ['value']);
+ *   await validationHelper.removeLinkContentTypeValues('contentTypeId', 'fieldId', ['some-content-type']);
  *   await validationHelper.removeInValues('contentTypeId', 'fieldId', ['value']);
  *
  * };
@@ -21,24 +22,12 @@ const { TYPE_LINK, TYPE_ARRAY } = require('../contentful');
 const getValidationHelpers = (migration, context) => {
   const { makeRequest } = context;
 
-  const addValidationValues = (validations, key, values = []) =>
-    validations.map((validation) => {
-      if (validation?.[key]) {
-        if (!Array.isArray(values)) {
-          values = [values];
-        }
-        if (!Array.isArray(validation[key])) {
-          throw new Error(
-            `addValidationValues can only be used on arrays. validation.${key} is typeof ${typeof validation[key]}`
-          );
-        }
-        validation[key] = [...new Set([...validation[key], ...values])];
-      }
+  const addValidationValues = (existingValues, newValues = []) => unique([...existingValues, ...newValues]);
 
-      return validation;
-    });
+  const removeValidationValues = (existingValues, newValues = []) =>
+    existingValues.filter((x) => !newValues.includes(x));
 
-  const removeValidationValues = (validations, key, values = []) =>
+  const modifyValidations = (validations, method, key, values) =>
     validations.map((validation) => {
       if (validation?.[key]) {
         if (!Array.isArray(values)) {
@@ -46,16 +35,18 @@ const getValidationHelpers = (migration, context) => {
         }
         if (!Array.isArray(validation[key])) {
           throw new Error(
-            `removeValidationValues can only be used on arrays. validation.${key} is typeof ${typeof validation[key]}`
+            `modifying validation properties is only supported on arrays. validation.${key} is typeof ${typeof validation[
+              key
+            ]}`
           );
         }
-        validation[key] = validation[key].filter((x) => !values.includes(x));
+        validation[key] = method(validation[key], values);
       }
 
       return validation;
     });
 
-  const modifyValidationValuesForType = async (validationKey, method, contentTypeId, fieldId, typeIds) => {
+  const modifyValidationValuesForType = async (validationKey, method, contentTypeId, fieldId, values) => {
     // Fetch content type
     const { fields } = await makeRequest({
       method: 'GET',
@@ -63,32 +54,71 @@ const getValidationHelpers = (migration, context) => {
     });
 
     const { type, items = {}, validations = [] } = fields?.find((field) => field.id === fieldId) ?? {};
+    if (type === undefined) {
+      throw new Error(`Content type ${contentTypeId} has no field ${fieldId}`);
+    }
 
     if (type === TYPE_ARRAY) {
       const ct = migration.editContentType(contentTypeId);
-      ct.editField(fieldId).items({ ...items, validations: method(items?.validations ?? [], validationKey, typeIds) });
+      ct.editField(fieldId).items({
+        ...items,
+        validations: modifyValidations(items?.validations, method, validationKey, values),
+      });
     } else {
       const ct = migration.editContentType(contentTypeId);
-      ct.editField(fieldId).validations(method(validations ?? [], validationKey, typeIds));
+      ct.editField(fieldId).validations(modifyValidations(validations, method, validationKey, values));
     }
   };
 
   return {
+    /**
+     * Add the specified values to the list of allowed content type values
+     */
     async addLinkContentTypeValues(contentTypeId, fieldId, values) {
       await modifyValidationValuesForType('linkContentType', addValidationValues, contentTypeId, fieldId, values);
     },
 
-    async addInValues(contentTypeId, fieldId, values) {
-      await modifyValidationValuesForType('in', addValidationValues, contentTypeId, fieldId, values);
+    /**
+     * Add the specified values to the list of allowed values
+     * @param {string} options.mode The mode how to add the values (sorted, start, end, before, after)
+     * @param {string|undefined} options.ref The reference value for mode "before" and "after"
+     */
+    async addInValues(contentTypeId, fieldId, values, options = {}) {
+      const addValuesWithOptions = (existingValues, newValues = []) => addValues(existingValues, newValues, options);
+      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);
     },
 
+    /**
+     * Remove the specified values from the list of allowed values
+     */
     async removeInValues(contentTypeId, fieldId, values) {
       await modifyValidationValuesForType('in', removeValidationValues, contentTypeId, fieldId, values);
     },
+
+    /**
+     * Modifies the list of allowed content types by calling the valueMappingFunction with the existing values and
+     * setting the result as the new value list.
+     */
+    async modifyLinkContentTypeValues(contentTypeId, fieldId, valueMappingFunction) {
+      const uniqueMappingFunction = (values) => unique(valueMappingFunction(values));
+      await modifyValidationValuesForType('linkContentType', uniqueMappingFunction, contentTypeId, fieldId, []);
+    },
+
+    /**
+     * Modifies the list of allowed values by calling the valueMappingFunction with the existing values and setting the
+     * result as the new value list.
+     */
+    async modifyInValues(contentTypeId, fieldId, valueMappingFunction) {
+      const uniqueMappingFunction = (values) => unique(valueMappingFunction(values));
+      await modifyValidationValuesForType('in', uniqueMappingFunction, contentTypeId, fieldId, []);
+    },
   };
 };
 

package/lib/helpers/validation.test.js

@@ -0,0 +1,171 @@
+const { getValidationHelpers } = require('./validation');
+
+describe('getValidationHelpers', () => {
+  const getTestContentType = () => ({
+    fields: [
+      {
+        id: 'selectWithOtherValidationProps',
+        type: 'Text',
+        items: [],
+        validations: [
+          {
+            foo: 'test',
+          },
+          {
+            in: ['foo', 'bar', 'baz'],
+            message: 'Some message',
+          },
+        ],
+      },
+      {
+        id: 'select',
+        type: 'Text',
+        items: [],
+        validations: [
+          {
+            in: ['foo', 'bar', 'baz'],
+          },
+        ],
+      },
+      {
+        id: 'reference',
+        type: 'Text',
+        validations: [
+          {
+            linkContentType: ['foo', 'bar', 'baz'],
+          },
+        ],
+      },
+      {
+        id: 'string-array',
+        type: 'Array',
+        items: [],
+      },
+    ],
+  });
+
+  const context = {
+    makeRequest: () => Promise.resolve(getTestContentType()),
+  };
+
+  let resultValidation;
+
+  const migration = {
+    editContentType: () => ({
+      editField: () => ({
+        validations: (validationObject) => {
+          resultValidation = validationObject;
+        },
+      }),
+    }),
+  };
+
+  beforeEach(() => {
+    resultValidation = undefined;
+  });
+
+  describe('addInValues', () => {
+    it('should add values at the end', async () => {
+      const validations = getValidationHelpers(migration, context);
+      await validations.addInValues('some-content-type', 'selectWithOtherValidationProps', 'bat');
+      expect(resultValidation).toEqual([
+        {
+          foo: 'test',
+        },
+        {
+          in: ['foo', 'bar', 'baz', 'bat'],
+          message: 'Some message',
+        },
+      ]);
+    });
+
+    it('should only add new values', async () => {
+      const validations = getValidationHelpers(migration, context);
+      await validations.addInValues('some-content-type', 'select', ['bat', 'foo', 'test']);
+      expect(resultValidation).toEqual([
+        {
+          in: ['foo', 'bar', 'baz', 'bat', 'test'],
+        },
+      ]);
+    });
+
+    it('should add new values sorted', async () => {
+      const validations = getValidationHelpers(migration, context);
+      await validations.addInValues('some-content-type', 'select', ['bat', 'foo', 'test'], { mode: 'sorted' });
+      expect(resultValidation).toEqual([
+        {
+          in: ['bar', 'bat', 'baz', 'foo', 'test'],
+        },
+      ]);
+    });
+  });
+
+  describe('removeInValues', () => {
+    it('should remove values', async () => {
+      const validations = getValidationHelpers(migration, context);
+      await validations.removeInValues('some-content-type', 'select', ['foo', 'baz']);
+      expect(resultValidation).toEqual([
+        {
+          in: ['bar'],
+        },
+      ]);
+    });
+  });
+
+  describe('modifyInValues', () => {
+    it('should modify values with custom function', async () => {
+      const validations = getValidationHelpers(migration, context);
+      await validations.modifyInValues('some-content-type', 'select', (values) => {
+        const result = values.slice(0, values.length - 1); // remove bar
+        result.push('test');
+        return result;
+      });
+      expect(resultValidation).toEqual([
+        {
+          in: ['foo', 'bar', 'test'],
+        },
+      ]);
+    });
+  });
+
+  describe('addLinkContentTypeValues', () => {
+    it('should add values at the end', async () => {
+      const validations = getValidationHelpers(migration, context);
+      await validations.addLinkContentTypeValues('some-content-type', 'reference', 'bat');
+      expect(resultValidation).toEqual([
+        {
+          linkContentType: ['foo', 'bar', 'baz', 'bat'],
+        },
+      ]);
+    });
+  });
+
+  describe('removeLinkContentTypeValues', () => {
+    it('should remove values', async () => {
+      const validations = getValidationHelpers(migration, context);
+      await validations.removeLinkContentTypeValues('some-content-type', 'reference', ['foo', 'baz']);
+      expect(resultValidation).toEqual([
+        {
+          linkContentType: ['bar'],
+        },
+      ]);
+    });
+  });
+
+  describe('modifyLinkContentTypeValues', () => {
+    it('should modify unique values with custom function', async () => {
+      const validations = getValidationHelpers(migration, context);
+      await validations.modifyLinkContentTypeValues('some-content-type', 'reference', (values) => {
+        const result = values.slice(0, values.length - 1); // remove bar
+        result.push('test');
+        result.push('foo'); // should be removed since it exists
+        return result;
+      });
+      expect(resultValidation).toEqual([
+        {
+          linkContentType: ['foo', 'bar', 'test'],
+        },
+      ]);
+    });
+  });
+});

package/lib/helpers/validation.utils.js

@@ -0,0 +1,76 @@
+/**
+ * Returns a new array containing only the unique values of the given array.
+ * The given order of the elements is kept.
+ * If duplicates exist the first occurrence is kept and the others are removed.
+ */
+const unique = (array) => [...new Set(array)];
+
+/**
+ * Returns an array with the unique items of both arrays sorted by natural ordering.
+ * @param {Array} array1
+ * @param {Array} array2
+ */
+const addOrdered = (array1, array2) => {
+  const result = [...new Set([...array1, ...array2])];
+  result.sort();
+  return result;
+};
+
+const ADD_MODE_SORTED = 'sorted';
+const ADD_MODE_START = 'start';
+const ADD_MODE_END = 'end';
+const ADD_MODE_BEFORE = 'before';
+const ADD_MODE_AFTER = 'after'; // default
+
+/**
+ * Get the insert position depending on the options.
+ * @param {string[]} array The array where values should be added.
+ * @param {string} options.mode The mode how to add the values (sorted, start, end, before, after)
+ * @param {string|undefined} options.ref The reference value for mode "before" and "after"
+ * @returns {number}
+ */
+const getInsertPosition = (array, options = {}) => {
+  if (options.mode === ADD_MODE_START) {
+    return 0;
+  }
+  if (options.mode === ADD_MODE_END) {
+    return array.length;
+  }
+
+  let refIndex = array.indexOf(options.ref);
+  if (refIndex >= 0) {
+    if (options.mode === ADD_MODE_BEFORE) {
+      return refIndex;
+    }
+    if (options.mode === ADD_MODE_AFTER) {
+      return refIndex + 1;
+    }
+  }
+
+  // default at the end
+  return array.length;
+};
+
+/**
+ * Adds values to a string array depending on the specified mode.
+ * The result list always contains unique values by calling the unique function.
+ * @param {string[]} array The array where values should be added.
+ * @param {string[]} toAdd The list of values to add.
+ * @param {string} options.mode The mode how to add the values (sorted, start, end, before, after)
+ * @param {string|undefined} options.ref The reference value for mode "before" and "after"
+ * @returns {string[]}
+ */
+const addValues = (array, toAdd, options = {}) => {
+  if (options.mode === ADD_MODE_SORTED) {
+    return addOrdered(array, toAdd);
+  }
+
+  let position = getInsertPosition(array, options);
+  return unique([...array.slice(0, position), ...toAdd, ...array.slice(position)]);
+};
+
+module.exports = {
+  addOrdered,
+  addValues,
+  unique,
+};

package/lib/helpers/validation.utils.test.js

@@ -0,0 +1,45 @@
+const { addOrdered, addValues, unique } = require('./validation.utils');
+
+describe('unique', () => {
+  it('should remove duplicates', async () => {
+    expect(unique(['foo', 'bar', 'foo', 'baz', 'bar'])).toEqual(['foo', 'bar', 'baz']);
+  });
+});
+
+describe('addOrdered', () => {
+  const a1 = ['foo', 'bar'];
+  const a2 = ['baz', 'bar', 'bat'];
+
+  it('should add unique values and order the list', async () => {
+    expect(addOrdered(a1, a2)).toEqual(['bar', 'bat', 'baz', 'foo']);
+  });
+});
+
+describe('addValues', () => {
+  const a1 = ['foo', 'bar', 'test'];
+  const a2 = ['baz', 'bar', 'bat'];
+
+  it('should add values sorted', async () => {
+    expect(addValues(a1, a2, { mode: 'sorted' })).toEqual(['bar', 'bat', 'baz', 'foo', 'test']);
+  });
+
+  it('should add values at start', async () => {
+    expect(addValues(a1, a2, { mode: 'start' })).toEqual(['baz', 'bar', 'bat', 'foo', 'test']);
+  });
+
+  it('should add values at end', async () => {
+    expect(addValues(a1, a2, { mode: 'end' })).toEqual(['foo', 'bar', 'test', 'baz', 'bat']);
+  });
+
+  it('should add values before', async () => {
+    expect(addValues(a1, a2, { mode: 'before', ref: 'bar' })).toEqual(['foo', 'baz', 'bar', 'bat', 'test']);
+  });
+
+  it('should add values before fallback', async () => {
+    expect(addValues(a1, a2, { mode: 'before', ref: 'unknown' })).toEqual(['foo', 'bar', 'test', 'baz', 'bat']);
+  });
+
+  it('should add values after', async () => {
+    expect(addValues(a1, a2, { mode: 'after', ref: 'bar' })).toEqual(['foo', 'bar', 'baz', 'bat', 'test']);
+  });
+});

package/lib/migration.js

@@ -93,10 +93,12 @@ const fetchMigration = async (config) => {
         .toString()
         // Add call to utils.getDefaultLocale() to the top
         .replace(
-          'module.exports = function (migration) {',`
+          'module.exports = function (migration) {',
+          `
           ${migrationHeader}
           const defaultLocale = helpers.locale.getDefaultLocale();
-        `)
+        `
+        )
         // Replace the default locale with defaultLocale.code so that the migration
         // still works as expected when the locale is changed in contentful
         .replace(testDefaultValueRegex, '$1[defaultLocale.code]$2')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jungvonmatt/contentful-migrations",
-  "version": "5.2.2",
+  "version": "5.3.0",
   "description": "Helper to handle migrations in contentful",
   "main": "index.js",
   "files": [
@@ -15,8 +15,9 @@
     "migrations": "cli.js"
   },
   "scripts": {
-    "test": "npm run lint",
-    "lint": "eslint .  --ext .js,.ts,.tsx --ignore-path .gitignore"
+    "test": "jest --coverage && npm run lint",
+    "lint": "eslint .  --ext .js,.ts,.tsx --ignore-path .gitignore",
+    "fix-lint": "npm run lint -- --fix"
   },
   "repository": {
     "type": "git",
@@ -61,11 +62,13 @@
     "read-pkg-up": "^9.0.0"
   },
   "devDependencies": {
-    "babel-eslint": "^10.1.0",
+    "@babel/eslint-parser": "^7.17.0",
     "eslint": "^8.3.0",
     "eslint-config-prettier": "^8.3.0",
     "eslint-plugin-prettier": "^4.0.0",
     "husky": "^7.0.4",
+    "jest": "^27.5.1",
+    "jest-sonar-reporter": "^2.0.0",
     "lint-staged": "^12.1.2"
   },
   "publishConfig": {
@@ -76,6 +79,9 @@
     "printWidth": 120
   },
   "eslintConfig": {
+    "ignorePatterns": [
+      "**/*.d.ts"
+    ],
     "plugins": [
       "prettier"
     ],
@@ -85,8 +91,9 @@
     "extends": [
       "prettier"
     ],
-    "parser": "babel-eslint",
+    "parser": "@babel/eslint-parser",
     "parserOptions": {
+      "requireConfigFile": false,
       "allowImportExportEverywhere": true,
       "ecmaFeatures": {
         "ecmaVersion": 2017,
@@ -106,6 +113,29 @@
       "prettier --write"
     ]
   },
+  "jest": {
+    "testResultsProcessor": "jest-sonar-reporter",
+    "coverageDirectory": "<rootDir>/__coverage__/",
+    "collectCoverageFrom": [
+      "<rootDir>/lib/*/**"
+    ],
+    "roots": [
+      "<rootDir>/lib/"
+    ],
+    "moduleFileExtensions": [
+      "js"
+    ],
+    "testRegex": "/lib/.*\\.test.js$",
+    "moduleDirectories": [
+      "node_modules"
+    ],
+    "globals": {
+      "DEVELOPMENT": false
+    },
+    "reporters": [
+      "default"
+    ]
+  },
   "husky": {
     "hooks": {
       "pre-commit": "lint-staged"
@@ -115,5 +145,10 @@
     "storage": "content",
     "migrationContentTypeId": "contentful-migrations",
     "directory": "migrations"
+  },
+  "jestSonar": {
+    "reportPath": "__coverage__",
+    "reportFile": "test-report.xml",
+    "indent": 2
   }
 }