@jungvonmatt/contentful-migrations 6.2.6 → 7.0.0

package/package.json

@@ -1,153 +1,90 @@
 {
   "name": "@jungvonmatt/contentful-migrations",
-  "version": "6.2.6",
+  "version": "7.0.0",
   "description": "Helper to handle migrations in contentful",
-  "main": "index.js",
-  "files": [
-    "index.d.ts",
-    "index.js",
-    "cli.js",
-    "lib"
+  "keywords": [
+    "content-type",
+    "contentful",
+    "migration"
   ],
-  "typings": "index.d.ts",
-  "bin": {
-    "contentful-migrations": "cli.js",
-    "migrations": "cli.js"
-  },
+  "license": "MIT",
+  "author": "Ben Zörb <benjamin.zoerb@jvm.de>",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/jungvonmatt/contentful-migrations.git"
   },
-  "author": "Ben Zörb <benjamin.zoerb@jvm.de>",
-  "license": "MIT",
-  "engines": {
-    "node": ">=18"
+  "bin": {
+    "contentful-migrations": "cli.js",
+    "migrations": "cli.js"
   },
-  "keywords": [
-    "contentful",
-    "migration",
-    "content-type"
+  "files": [
+    "index.d.ts",
+    "index.js",
+    "cli.js",
+    "lib",
+    "!lib/**/*.test.js"
   ],
+  "main": "index.js",
+  "typings": "index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
   "dependencies": {
-    "@contentful/rich-text-plain-text-renderer": "^17.1.6",
-    "@jungvonmatt/contentful-config": "^4.0.3",
-    "array.prototype.flatmap": "^1.3.3",
+    "@contentful/rich-text-plain-text-renderer": "^17.2.1",
+    "@jungvonmatt/contentful-config": "^5.0.1",
     "ascii-tree": "^0.3.0",
     "cli-progress": "^3.12.0",
-    "commander": "^8.3.0",
+    "commander": "^14.0.3",
     "common-tags": "^1.8.2",
-    "contentful-cli": "^3.10.2",
-    "contentful-import": "^9.4.129",
-    "contentful-management": "^11.67.0",
-    "contentful-migration": "^4.31.5",
-    "deep-diff": "^1.0.2",
-    "diff": "^5.1.0",
+    "contentful-cli": "^4.0.1",
+    "contentful-import": "^10.0.5",
+    "contentful-management": "^12.5.0",
+    "contentful-migration": "^5.0.0",
+    "diff": "^9.0.0",
     "enquirer": "^2.4.1",
-    "fs-extra": "^10.1.0",
-    "globby": "^12.0.2",
+    "fs-extra": "^11.3.5",
     "markdown-table": "^3.0.4",
     "merge-options": "^3.0.4",
+    "microdiff": "^1.5.0",
     "mustache": "^4.2.0",
-    "node-fetch": "^3.3.2",
-    "node-object-hash": "^2.3.10",
-    "picocolors": "^1.0.0",
-    "pkg-up": "^4.0.0",
-    "prettier": "^2.7.1",
-    "read-pkg-up": "^9.1.0"
+    "node-object-hash": "^3.1.1",
+    "oxfmt": "^0.50.0",
+    "package-up": "^5.0.0",
+    "picocolors": "^1.1.1",
+    "read-package-up": "^12.0.0",
+    "tinyglobby": "^0.2.16"
   },
   "devDependencies": {
-    "@babel/eslint-parser": "^7.28.5",
-    "eslint": "^8.20.0",
-    "eslint-config-prettier": "^8.5.0",
-    "eslint-plugin-prettier": "^4.2.1",
-    "husky": "^7.0.4",
-    "jest": "^27.5.1",
-    "jest-sonar-reporter": "^2.0.0",
-    "lint-staged": "^12.1.2"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "prettier": {
-    "singleQuote": true,
-    "printWidth": 120
+    "@vitest/coverage-v8": "^4.1.6",
+    "husky": "^9.1.7",
+    "lint-staged": "^17.0.5",
+    "oxlint": "^1.65.0",
+    "vitest": "^4.1.6"
   },
-  "eslintConfig": {
-    "ignorePatterns": [
-      "**/*.d.ts"
-    ],
-    "plugins": [
-      "prettier"
-    ],
-    "rules": {
-      "prettier/prettier": "error"
-    },
-    "extends": [
-      "prettier"
-    ],
-    "parser": "@babel/eslint-parser",
-    "parserOptions": {
-      "requireConfigFile": false,
-      "allowImportExportEverywhere": true,
-      "ecmaFeatures": {
-        "ecmaVersion": 2017,
-        "impliedStrict": true
-      }
-    },
-    "env": {
-      "node": true
+  "husky": {
+    "hooks": {
+      "pre-commit": "lint-staged"
     }
   },
   "lint-staged": {
     "*.{js,jsx,ts,tsx}": [
-      "prettier --write --ignore-path .gitignore",
-      "eslint --fix --ignore-path .gitignore"
-    ],
-    "*.md": [
-      "prettier --write"
+      "oxfmt",
+      "oxlint --fix"
     ]
   },
-  "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"
-    }
+  "engines": {
+    "node": ">=22"
   },
   "migrations": {
     "storage": "content",
     "migrationContentTypeId": "contentful-migrations",
     "directory": "migrations"
   },
-  "jestSonar": {
-    "reportPath": "__coverage__",
-    "reportFile": "test-report.xml",
-    "indent": 2
-  },
   "scripts": {
-    "test": "jest --coverage && pnpm run lint",
-    "lint": "eslint .  --ext .js,.ts,.tsx --ignore-path .gitignore",
-    "fix-lint": "pnpm run lint -- --fix"
+    "test": "vitest run --coverage && pnpm run lint",
+    "lint": "oxlint",
+    "fix-lint": "oxlint --fix",
+    "fmt": "oxfmt",
+    "fmt:check": "oxfmt --check"
   }
 }

package/lib/helpers/validation.test.js

@@ -1,381 +0,0 @@
-const { getValidationHelpers } = require('./validation');
-
-describe('getValidationHelpers', () => {
-  const getTestContentType = () => ({
-    fields: [
-      {
-        id: 'selectWithOtherValidationProps',
-        type: 'Text',
-        validations: [
-          {
-            foo: 'test',
-          },
-          {
-            in: ['foo', 'bar', 'baz'],
-            message: 'Some message',
-          },
-        ],
-      },
-      {
-        id: 'select',
-        type: 'Text',
-        validations: [
-          {
-            in: ['foo', 'bar', 'baz'],
-          },
-        ],
-      },
-      {
-        id: 'reference',
-        type: 'Text',
-        validations: [
-          {
-            linkContentType: ['foo', 'bar', 'baz'],
-          },
-        ],
-      },
-      {
-        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'],
-                },
-              ],
-            },
-          },
-        ],
-      },
-    ],
-  });
-
-  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'],
-        },
-      ]);
-    });
-
-    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', () => {
-    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'],
-        },
-      ]);
-    });
-  });
-
-  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/helpers/validation.utils.test.js

@@ -1,45 +0,0 @@
-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']);
-  });
-});