@localazy/strapi-plugin 0.1.14 → 0.1.16

package/server/utils/__tests__/parsed-localazy-entry-to-create-entry.test.js

@@ -5,7 +5,7 @@ const allModels = require("../../tests/fixtures/strapi-plugin-all-models");
 const simpleMenuWithMediaModel = require("../../tests/fixtures/parsed-localazy-entry-to-create-entry-restaurant-simple-menu");
 const cookbookModel = require("../../tests/fixtures/parsed-localazy-entry-to-create-entry-cookbook");
 const lessonDZModel = require("../../tests/fixtures/parsed-localazy-entry-to-create-entry-lesson-dz");
-const sampleJSONDZModel = require("../../tests/fixtures/parsed-localazy-entry-to-create-entry-sample-json-dz");
+const pageDZModel = require("../../tests/fixtures/parsed-localazy-entry-to-create-entry-page-dz");
 
 describe("parsed-localazy-entry-to-create-entry.js", () => {
   it("should return transformed 'restaurant-simple-menu' entry to strapi create entry structure", () => {
@@ -123,24 +123,23 @@ describe("parsed-localazy-entry-to-create-entry.js", () => {
     expect(result).toEqual(expected);
   });
 
-  it("should return transformed 'lesson' entry including Dynamic Zones to strapi create entry structure", () => {
+  it("should return transformed 'lesson' entry including Dynamic Zones to strapi create entry structure (for existing entry)", () => {
     // EXECUTE
     const result = parsedLocalazyEntryToCreateEntry(
       allModels,
       lessonDZModel.parsedLocalazyEntry,
       lessonDZModel.baseEntry,
       lessonDZModel.uid,
-      lessonDZModel.locale
     );
 
     // VERIFY
     const expected = {
       createEntry: {
-        title: "Test: Sčítání",
+        title: "Test: Přidání",
         description: "Otestujte si své dovednosti, které jsme se naučili v předchozí lekci.",
         lesson_type: [
           {
-            title: "Vyberte správnou odpověď",
+            title: "Zvolte správnou odpověď",
             __component: "lesson.quiz",
             questions: [
               {
@@ -152,7 +151,7 @@ describe("parsed-localazy-entry-to-create-entry.js", () => {
                 __component: "lesson.survey-question",
               },
               {
-                question: "Kolik pohárů je na fotce?",
+                question: "Kolik šálků je na fotografii?",
                 __component: "lesson.survey-question",
               },
             ],
@@ -172,7 +171,6 @@ describe("parsed-localazy-entry-to-create-entry.js", () => {
             ],
           },
         ],
-        locale: "cs",
       },
       dynamicZoneComponentKeys: [
         {
@@ -185,85 +183,76 @@ describe("parsed-localazy-entry-to-create-entry.js", () => {
     expect(result).toEqual(expected);
   });
 
-  it("should return transformed 'sample-json' entry including Dynamic Zones to strapi create entry structure", () => {
+  it("should return transformed 'page' entry including Dynamic Zones to strapi create entry structure (for non-existing entry)", () => {
     // EXECUTE
-    const result = parsedLocalazyEntryToCreateEntry(
+    const { createEntry } = parsedLocalazyEntryToCreateEntry(
       allModels,
-      sampleJSONDZModel.parsedLocalazyEntry,
-      sampleJSONDZModel.baseEntry,
-      sampleJSONDZModel.uid,
+      pageDZModel.parsedLocalazyEntry,
+      pageDZModel.baseEntry,
+      pageDZModel.uid,
+      pageDZModel.locale,
     );
 
     // VERIFY
     const expected = {
-      createEntry: {
-        purpose: "Bar",
-        repeatable_component_property: [
-          {
-            name: "Položka 1",
-            __component: "restaurant.menu-item",
-            description: "Nějaký popis",
-          },
-          {
-            name: "Položka 2",
-            __component: "restaurant.menu-item",
-            description: "Nějaký další popis",
-          },
-        ],
-        dynamic_property: [
-          {
-            image_title: "Nějaký název obrázku",
-            __component: "food.gallery-item",
-            image_description: "Nějaký popis obrázku",
-          },
-          {
-            name: "Přísada I",
-            __component: "food.recipe-ingredient",
-          },
-          {
-            name: "První položka CB",
-            __component: "food.cookbook-item",
-            author_name: "Já",
-            ingredients: [
-              {
-                name: "První Ingr DZ",
-                __component: "food.recipe-ingredient",
-              },
-            ],
-            gallery: [
-              {
-                image_title: "Obrázek G Jedna",
-                __component: "food.gallery-item",
-                image_description: "Obrázek G Popis Jedna",
-              },
-            ],
-          },
-          {
-            name: "Druhá přísada",
-            __component: "food.recipe-ingredient",
-          },
-        ],
+      title: "Software IP Intelligence",
+      slug: "ip-intelligence-software",
+      path: "/ip-intelligence software",
+      seo: {
+        __component: "seo.seo",
+        title: "Software IP Intelligence",
+        description: "Popis stránky IP Intelligence Software.",
+        canonical: "ip-intelligence-software",
       },
-      dynamicZoneComponentKeys: [
-        {
-          key: "dynamic_property.2.__component",
-          component: "food.cookbook-item",
-        },
-        {
-          key: "dynamic_property.0.__component",
-          component: "food.gallery-item",
-        },
-        {
-          key: "dynamic_property.1.__component",
-          component: "food.recipe-ingredient",
+      hero: {
+        __component: "global.hero",
+        preTitle: "Inteligentní software před IP",
+        title: "Inteligentní software před IP",
+        text: "Text softwaru Hero Pre-IP Intelligence",
+        animatedText: {
+          __component: "hero.animated-text",
+          items: [
+            {
+              text: "hej",
+              __component: "hero.animated-text-items",
+            },
+            {
+              text: "Člověk",
+              __component: "hero.animated-text-items",
+            },
+            {
+              text: "Úžasné",
+              __component: "hero.animated-text-items",
+            },
+            {
+              text: "Práce!",
+              __component: "hero.animated-text-items",
+            },
+          ],
         },
+      },
+      components: [
+        undefined,
         {
-          key: "dynamic_property.3.__component",
-          component: "food.recipe-ingredient",
+          items: [
+            {
+              text: "Funkce One",
+              __component: "global.feature",
+            },
+            {
+              text: "Funkce dva",
+              __component: "global.feature",
+            },
+            {
+              text: "Funkce tři",
+              __component: "global.feature",
+            },
+          ],
         },
-      ]
+      ],
+      locale: "cs",
     };
 
-    expect(result).toEqual(expected);
+    expect(createEntry).toEqual(expected);
   });
 });

package/server/utils/__tests__/parsed-localazy-entry-to-update-entry.test.js

@@ -11,7 +11,20 @@ const {
   locale,
 } = require("../../tests/fixtures/parsed-localazy-entry-to-update-entry");
 
+const mocks = require("../../../test/helpers/mocks");
+
 describe("parsed-localazy-entry-to-update-entry.js", () => {
+  Object.defineProperty(global, "strapi", {
+    value: mocks.strapi,
+  });
+  jest.spyOn(mocks.strapi.entityService, "findOne").mockImplementation(() => {
+    return {
+      id: 24,
+      title: "Pro každý den v roce",
+      localizations: [],
+    }
+  });
+
   it("should return transformed 'cookbook' entry to strapi update entry structure", async () => {
     // EXECUTE
     const result = await parsedLocalazyEntryToUpdateEntry(

package/server/utils/__tests__/pick-entries.test.js

@@ -893,19 +893,19 @@ describe("pick entries test suite", () => {
       "api::lesson.lesson[1].start_time": "2022-09-28T09:00:00.000Z",
       "api::lesson.lesson[1].duration": "03:00:00.000",
       "api::lesson.lesson[1].description": "## Description\n\nIn this lesson, we'll learn about addition and what rules to follow...",
-      "api::lesson.lesson[1].lesson_type[1].__component": "lesson.lecture",
-      "api::lesson.lesson[1].lesson_type[1].content": "You need to follow these rules:\na) add one number to the other\nb) do not subtract nor multiply\nc) ...",
+      "api::lesson.lesson[1].lesson_type[1;lesson.lecture].__component": "lesson.lecture",
+      "api::lesson.lesson[1].lesson_type[1;lesson.lecture].content": "You need to follow these rules:\na) add one number to the other\nb) do not subtract nor multiply\nc) ...",
     };
 
     const pickPaths = [
       "api::lesson.lesson.title",
       "api::lesson.lesson.description",
-      "api::lesson.lesson.lesson_type[0].content",
-      "api::lesson.lesson.lesson_type[1].description",
-      "api::lesson.lesson.lesson_type[1].questions.question",
-      "api::lesson.lesson.lesson_type[2].title",
-      "api::lesson.lesson.lesson_type[2].questions.question",
-      "api::lesson.lesson.lesson_type[2].answers.correct_answer",
+      "api::lesson.lesson.lesson_type[lecture].content",
+      "api::lesson.lesson.lesson_type[survey].description",
+      "api::lesson.lesson.lesson_type[survey].questions.question",
+      "api::lesson.lesson.lesson_type[quiz].title",
+      "api::lesson.lesson.lesson_type[quiz].questions.question",
+      "api::lesson.lesson.lesson_type[quiz].answers.correct_answer",
       "api::lesson.lesson.id",
     ];
 

package/server/utils/__tests__/populate-create-update-entry-with-base-entry.test.js

@@ -13,7 +13,22 @@ const lessonWithDZsModel = require("../../tests/fixtures/populate-create-update-
 
 const populateCreateUpdateEntryWithBaseEntry = require("../populate-create-update-entry-with-base-entry");
 
+
+
+const mocks = require("../../../test/helpers/mocks");
+
 describe("populate-create-update-entry-with-base-entry.js", () => {
+  Object.defineProperty(global, "strapi", {
+    value: mocks.strapi,
+  });
+  jest.spyOn(mocks.strapi.entityService, "findOne").mockImplementation(() => {
+    return {
+      id: 24,
+      title: "Pro každý den v roce",
+      localizations: [],
+    }
+  });
+
   it("should populate a 'restaurant-simple-flat' correctly", async () => {
     const populatedEntry = await populateCreateUpdateEntryWithBaseEntry(
       allModels,

package/server/utils/flatten-object.js

@@ -22,8 +22,13 @@ const flattenObject = (object, prefix = "") => {
         const flattenedArray = object[objectKey].reduce(
           (accumulator, item, index) => {
             // No id should use the index of the array item
-            accumulator[`${objectKey}[${item.id || index}]`] =
-              flattenObject(item);
+            let key = `${objectKey}[${item.id || index}]`;
+            // is Dynamic Zone
+            if (item.id && item.__component) {
+              key = `${objectKey}[${item.id};${item.__component}]`;
+            }
+
+            accumulator[key] = flattenObject(item);
             return accumulator;
           },
           {}

package/server/utils/parsed-localazy-entry-to-create-entry.js

@@ -19,13 +19,13 @@ const parsedLocalazyEntryToCreateEntry = (
   const toCreateEntry = (
     entry,
     model,
-    baseEntry,
     // eslint-disable-next-line no-unused-vars
     key = "",
     prefix = "",
     component = "",
     isRepeatableComponent = false,
     isDZ = false,
+    isInsideDZ = false,
   ) => {
     if (Array.isArray(entry)) {
       // is array
@@ -41,13 +41,13 @@ const parsedLocalazyEntryToCreateEntry = (
             if (baseEntryRepeateableGroup !== undefined) {
               const localizedEntryRepeatableItemPosition = baseEntryRepeateableGroup.findIndex((repeatableItem) => !!repeatableItem && repeatableItem.id === baseEntryRepeatableItemId);
               if (localizedEntryRepeatableItemPosition > -1) {
-                toCreateEntry(value, model, baseEntry, localizedEntryRepeatableItemPosition, `${prefix}.${localizedEntryRepeatableItemPosition}`, component);
+                toCreateEntry(value, model, localizedEntryRepeatableItemPosition, `${prefix}.${localizedEntryRepeatableItemPosition}`, component);
               }
             }
           }
 
           if (component && !isRepeatableComponent) {
-            toCreateEntry(value, model, baseEntry, `${prefix}`, `${prefix}`);
+            toCreateEntry(value, model, `${prefix}`, `${prefix}`);
           }
 
           if (!component && isRepeatableComponent) {
@@ -66,7 +66,6 @@ const parsedLocalazyEntryToCreateEntry = (
                 toCreateEntry(
                   value,
                   dzEntryComponentModel,
-                  baseEntry,
                   localizedEntryRepeatableItemPosition,
                   `${prefix}.${localizedEntryRepeatableItemPosition}`,
                   dzEntryComponent,
@@ -78,6 +77,29 @@ const parsedLocalazyEntryToCreateEntry = (
           }
         }
       });
+    } else if (isDZ) {
+      Object.entries(entry).forEach(([dzEntryIdWithComponent, value]) => {
+        let [dzEntryId, dzEntryComponent] = dzEntryIdWithComponent.split(";");
+        dzEntryId = parseInt(dzEntryId);
+        const baseEntryDZEntry = get(baseEntry, prefix).find((v) => (v.id === dzEntryId) && (v.__component === dzEntryComponent));
+        if (baseEntryDZEntry !== undefined) {
+          const dzEntryComponentModel = findModel(models, dzEntryComponent);
+          toCreateEntry(
+            value,
+            dzEntryComponentModel,
+            dzEntryId,
+            `${prefix}.${dzEntryId}`,
+            dzEntryComponent,
+            true,
+            false, // we're already inside, so it's falsy
+            true,
+          );
+        }
+        /**
+         * Don't do anything if `baseEntryDZEntry` is `undefined` - it means that the entry was deleted
+         * That also automatically presumes that deal with `undefined` `baseEntryDZIndex` inside the Dynamic Zone
+         */
+      });
     } else {
       // is object
       Object.entries(entry).forEach(([objectKey, value]) => {
@@ -86,38 +108,34 @@ const parsedLocalazyEntryToCreateEntry = (
           // logicaly don't anything, skip...
         } else if (isComponent(attribute)) {
           // is component
-          const component = attribute.component;
-          const componentModel = findModel(models, component);
-          if (isRepeatable(attribute)) {
-            // is repeatable - array
-            const newPrefix = prefix
-              ? `${prefix}.${objectKey}`
-              : `${objectKey}`;
-            toCreateEntry(
-              value,
-              componentModel,
-              baseEntry,
-              objectKey,
-              newPrefix,
-              component,
-              true
-            );
-          } else {
-            // is no repeatable - object
-            const newPrefix = prefix
-              ? `${prefix}.${objectKey}`
-              : `${objectKey}`;
-            set(createEntry, `${newPrefix}.__component`, component);
-            toCreateEntry(
-              value,
-              componentModel,
-              baseEntry,
-              objectKey,
-              newPrefix,
-              component,
-              false
-            );
+          const innerComponent = attribute.component;
+          const componentModel = findModel(models, innerComponent);
+
+          let newPrefixBase = prefix;
+          let newPrefix = newPrefixBase
+            ? `${newPrefixBase}.${objectKey}`
+            : `${objectKey}`;
+          if (isInsideDZ) {
+            let [dzParamKey, dzEntryId] = newPrefixBase.split(".");
+            dzEntryId = parseInt(dzEntryId);
+            const baseEntryDZIndex = get(baseEntry, dzParamKey).findIndex((v) => (v.__component === component) && (v.id === dzEntryId));
+            newPrefixBase = `${dzParamKey}.${baseEntryDZIndex}`;
+            newPrefix = `${newPrefixBase}.${objectKey}`;
+          }
+          const isRepeatableComponent = isRepeatable(attribute);
+          if (!isRepeatableComponent) {
+            set(createEntry, `${newPrefix}.__component`, innerComponent);
           }
+          toCreateEntry(
+            value,
+            componentModel,
+            objectKey,
+            newPrefix,
+            innerComponent,
+            isRepeatableComponent,
+            false,
+            isInsideDZ,
+          );
         } else if (isDynamicZone(attribute)) {
           // behaves sort of like repeatable component
           const newPrefix = prefix
@@ -126,7 +144,6 @@ const parsedLocalazyEntryToCreateEntry = (
           toCreateEntry(
             value,
             null, // model is evaluated later as it's dynamic (DZ)
-            baseEntry,
             objectKey,
             newPrefix,
             "", // component is computed later as it's dynamic (DZ)
@@ -134,14 +151,22 @@ const parsedLocalazyEntryToCreateEntry = (
             true,
           );
         } else {
-          const newPrefix = prefix ? `${prefix}.${objectKey}` : `${objectKey}`;
+          let newPrefixBase = prefix;
+          let newPrefix = newPrefixBase ? `${newPrefixBase}.${objectKey}` : `${objectKey}`;
+          if (isInsideDZ) {
+            let [dzParamKey, dzEntryId] = newPrefixBase.split(".");
+            dzEntryId = parseInt(dzEntryId);
+            const baseEntryDZIndex = get(baseEntry, dzParamKey).findIndex((v) => (v.__component === component) && (v.id === dzEntryId));
+            newPrefixBase = `${dzParamKey}.${baseEntryDZIndex}`;
+            newPrefix = `${newPrefixBase}.${objectKey}`;
+          }
           set(createEntry, newPrefix, value);
 
           if (component) {
-            const componentKeyToSet = `${prefix}.__component`;
+            const componentKeyToSet = `${newPrefixBase}.__component`;
             set(createEntry, componentKeyToSet, component);
 
-            if (isDZ) {
+            if (isInsideDZ) {
               const isKeyAdded = (typeof dynamicZoneComponentKeys.find((v) => v.key === componentKeyToSet) !== "undefined");
               if (!isKeyAdded)
                 dynamicZoneComponentKeys.push({
@@ -157,7 +182,7 @@ const parsedLocalazyEntryToCreateEntry = (
   };
 
   const model = findModel(models, uid);
-  toCreateEntry(parsedLocalazyEntry, model, baseEntry);
+  toCreateEntry(parsedLocalazyEntry, model);
   if (locale) {
     createEntry.locale = locale;
   }

package/server/utils/parsed-localazy-entry-to-update-entry.js

@@ -22,6 +22,14 @@ const parsedLocalazyEntryToUpdateEntry = async (
     uid
   );
 
+  /**
+   * TODO: possibly improve for the following case:
+   * A `key` is deleted from the base entry, and the same `key` still exist in the localized entry.
+   * Even though the `key` is deprecated in Localazy, it concludes that the `key` is still used in the localized entry.
+   * Therefore, it leads to an error when updating the entry.
+   *
+   * The solution for now: Delete the localized entry and re-download to force the creation process.
+   */
   let updateEntry = {};
   merge(updateEntry, currentEntry, createEntry);
   updateEntry = omitDeep(updateEntry, [

package/server/utils/pick-entries.js

@@ -1,93 +1,12 @@
 "use strict";
 
-const map = require("lodash/map");
-const pickDeep = require("./pick-deep");
-const flattenObject = require("./flatten-object");
-
-const isDynamicZoneKey = (key, transferSetupModel) => {
-  const matches = key.match(/\[\d+\]+/g);
-
-  if (matches.length < 2) {
-    return false;
-  }
-
-  const dynamicPropertyEntryIdWithSquareBrackets = matches[1];
-  const dynamicPropertyNamePart = key
-    .split(".")
-    .find(
-      (s, index) =>
-        index > 1 && s.includes(dynamicPropertyEntryIdWithSquareBrackets)
-    );
-  const dynamicPropertyName = dynamicPropertyNamePart.replace(
-    dynamicPropertyEntryIdWithSquareBrackets,
-    ""
-  );
-
-  return Array.isArray(transferSetupModel[dynamicPropertyName]);
-};
-
-const getDynamicZoneEntryId = (key, transferSetupModel) => {
-  if (!isDynamicZoneKey(key, transferSetupModel)) {
-    return undefined;
-  }
-
-  const matches = key.match(/\[\d+\]+/g);
-  // remove square brackets
-  const id = matches[1].replace(/[\[\]']+/g, "");
-  return id;
-};
-
-const getUniqueDynamicZoneEntryId = (key, transferSetupModel) => {
-  if (!isDynamicZoneKey(key, transferSetupModel)) {
-    return undefined;
-  }
-
-  const keySplittedByDot = key.split(".");
-
-  return keySplittedByDot[2];
-};
-
-const doesPickPathsIncludeTheComponent = (pickPaths, dzParameterKey) => {
-  return pickPaths.some((pp) => pp.includes(dzParameterKey));
+const isDynamicZoneKey = (key) => {
+  const matches = key.match(/\[\d+;\w+\./g);
+  return matches !== null;
 };
 
-const pickEntries = (flatten, pickPaths, transferSetupModel) => {
-  // * dynamic zones properties must! always be in 1st level (not in component; Strapi restrictions)
-
-  const dzEntryIdComponentMap = {};
-  const flattenComponentProps = Object.fromEntries(
-    Object.entries(flatten).filter(([key]) => key.includes("__component"))
-  );
-
-  const pickedDeep = pickDeep(transferSetupModel, ["__component__"]);
-  const flattenedPickedDeep = flattenObject(pickedDeep);
-  map(flattenedPickedDeep, (v, i) => {
-    const newI = i.replace(".__component__", "");
-    flattenedPickedDeep[newI] = v;
-    delete flattenedPickedDeep[i];
-  });
-
-  Object.keys(flattenComponentProps).map((key) => {
-    if (!isDynamicZoneKey(key, transferSetupModel)) {
-      return;
-    }
-
-    const keySplittedByDot = key.replace(".__component", "").split(".");
-    const componentName = keySplittedByDot[keySplittedByDot.length - 1].replace(
-      /\[.*\]/g,
-      ""
-    );
-    const uniqueEntryId = getUniqueDynamicZoneEntryId(key, transferSetupModel);
-
-    const keyOfEntry = Object.keys(flattenedPickedDeep)
-      .filter((fpdk) => fpdk.replace(/\[.*\]/g, "") == componentName)
-      .find((fpdk) => flattenedPickedDeep[fpdk] === flattenComponentProps[key]);
-    dzEntryIdComponentMap[uniqueEntryId] = {
-      component: flattenComponentProps[key],
-      key: keyOfEntry,
-    };
-  });
-
+const pickEntries = (flatten, pickPaths) => {
+  // * Dynamic zones properties must! always be in 1st level (not in component; Strapi restrictions)
   const pickedEntries = {};
   const mappedPickPaths = pickPaths.map((pickPath) =>
     pickPath.replace(/\[\d+\]/g, "")
@@ -98,44 +17,13 @@ const pickEntries = (flatten, pickPaths, transferSetupModel) => {
     Object.entries(flatten).filter(([key]) => !key.includes("__component"))
   );
   Object.keys(filteredFlatten).forEach((key) => {
-    // decide whether it is a dynamic zone
-    // handle dynamic zones, in case of similarly-named fields across more components
-    const isDynamicZone = isDynamicZoneKey(key, transferSetupModel);
-    if (isDynamicZone) {
-      const uniqueDzEntryId = getUniqueDynamicZoneEntryId(
-        key,
-        transferSetupModel
-      );
-      const dzParameterKey = dzEntryIdComponentMap[uniqueDzEntryId].key;
-
-      if (!doesPickPathsIncludeTheComponent(pickPaths, dzParameterKey)) {
-        return;
-      }
+    let filteredKey = key;
+    filteredKey = filteredKey.replace(/\[\d+\]/g, "");
+    if (isDynamicZoneKey(key)) {
+      filteredKey = filteredKey.replace(/\[\d+;\w+\./g, `[`);
     }
-
-    const filteredKey = key.replace(/\[\d+\]/g, "");
     if (mappedPickPaths.includes(filteredKey)) {
-      if (isDynamicZone) {
-        const dzEntryId = getDynamicZoneEntryId(key, transferSetupModel);
-        const uniqueDzEntryId = getUniqueDynamicZoneEntryId(
-          key,
-          transferSetupModel
-        );
-        const dzParameterKey = dzEntryIdComponentMap[uniqueDzEntryId].key;
-
-        const dzParameterName = dzParameterKey.substring(
-          0,
-          dzParameterKey.indexOf("[")
-        );
-        const toBeReplaced = `${dzParameterName}[${dzEntryId}]`;
-        const dzParameterComponent =
-          dzEntryIdComponentMap[uniqueDzEntryId].component;
-        const componentAddition = `${dzParameterName}[${dzEntryId};${dzParameterComponent}]`;
-        const replacedKey = key.replace(toBeReplaced, componentAddition);
-        pickedEntries[replacedKey] = flatten[key];
-      } else {
-        pickedEntries[key] = flatten[key];
-      }
+      pickedEntries[key] = flatten[key];
     }
   });
   return pickedEntries;

package/server/utils/populate-create-update-entry-with-base-entry.js

@@ -195,10 +195,6 @@ const populateCreateUpdateEntryWithBaseEntry = async (
         } else if (isRelation(attribute)) {
           const newPrefix = getNewPrefix(objectKey, prefix);
           const populatedLocalizedEntryVal = get(populatedLocalizedEntry, newPrefix);
-          if (doesExistInPopulatedLocalizedEntry(populatedLocalizedEntryVal)) {
-            // skip...
-            continue;
-          }
 
           const isArray = Array.isArray(value);
           let arraiedValue = value;