@localazy/strapi-plugin 0.1.10 → 0.1.11-rc.1

package/server/utils/build-populate.js

@@ -30,6 +30,11 @@ const buildPopulate = (models, modelUid) => {
           : `${attributeName}`;
         const innerModelUid = attribute.component;
         buildPopulateStep(models, innerModelUid, newPrefix);
+      } else if (attribute.type === "dynamiczone") {
+        const key = prefix
+          ? `${prefix}.${attributeName}.populate`
+          : `${attributeName}.populate`;
+        keys.push(key);
       }
     }
 

package/server/utils/get-full-populate-object.js

@@ -0,0 +1,56 @@
+// is taken from
+// https://github.com/Barelydead/strapi-plugin-populate-deep
+// based on the issue
+// https://github.com/strapi/strapi/issues/11836
+
+const isEmpty = require("lodash/isEmpty");
+const merge = require("lodash/merge");
+
+const getModelPopulationAttributes = (model) => {
+  if (model.uid === "plugin::upload.file") {
+    const { related, ...attributes } = model.attributes;
+    return attributes;
+  }
+
+  return model.attributes;
+};
+
+const getFullPopulateObject = (modelUid, maxDepth = 20) => {
+  if (maxDepth <= 1) {
+    return true;
+  }
+  if (modelUid === "admin::user") {
+    return undefined;
+  }
+
+  const populate = {};
+  const model = strapi.getModel(modelUid);
+  for (const [key, value] of Object.entries(
+    getModelPopulationAttributes(model)
+  )) {
+    if (value) {
+      if (value.type === "component") {
+        populate[key] = getFullPopulateObject(value.component, maxDepth - 1);
+      } else if (value.type === "dynamiczone") {
+        const dynamicPopulate = value.components.reduce((prev, cur) => {
+          const curPopulate = getFullPopulateObject(cur, maxDepth - 1);
+          return curPopulate === true ? prev : merge(prev, curPopulate);
+        }, {});
+        populate[key] = isEmpty(dynamicPopulate) ? true : dynamicPopulate;
+      } else if (value.type === "relation") {
+        const relationPopulate = getFullPopulateObject(
+          value.target,
+          maxDepth - 1
+        );
+        if (relationPopulate) {
+          populate[key] = relationPopulate;
+        }
+      } else if (value.type === "media") {
+        populate[key] = true;
+      }
+    }
+  }
+  return isEmpty(populate) ? true : { populate };
+};
+
+module.exports = getFullPopulateObject;

package/server/utils/get-models-tree.js

@@ -1,5 +1,7 @@
 "use strict";
 
+const SUPPORTED_CONTENT_TYPE_FIELDS = require("../models/supported-content-type-fields");
+
 const getModelTree = (attributes, models) => {
   const currentModelTree = {};
   for (const attribute in attributes) {
@@ -12,7 +14,7 @@ const getModelTree = (attributes, models) => {
         ...getModelTree(nestedModel.__schema__.attributes, models),
       };
     } else if (
-      ["string", "text", "richtext"].includes(attributes[attribute].type)
+      SUPPORTED_CONTENT_TYPE_FIELDS.includes(attributes[attribute].type)
     ) {
       currentModelTree[attribute] = false;
     } else {

package/server/utils/model-utils.js

@@ -0,0 +1,43 @@
+"use strict";
+
+const isEmpty = require("lodash/isEmpty");
+
+const getAttribute = (model, attribute) => {
+  if (isEmpty(model)) {
+    return undefined;
+  }
+
+  const attributeObj = model.attributes[attribute];
+  return attributeObj;
+};
+
+const isComponent = (attributeObj) => {
+  return attributeObj.type === "component";
+};
+
+const isDynamicZone = (attributeObj) => {
+  return attributeObj.type === "dynamiczone";
+}
+
+const isRepeatable = (attributeObj) => {
+  return isComponent(attributeObj) && !!attributeObj.repeatable;
+};
+
+const isRelation = (attributeObj) => {
+  return attributeObj.type === "relation"
+    && attributeObj.target !== "plugin::upload.file";
+};
+
+const findModel = (models, uid) => {
+  const model = models.find((model) => model.uid === uid);
+  return model;
+};
+
+module.exports = {
+  getAttribute,
+  isComponent,
+  isDynamicZone,
+  isRepeatable,
+  isRelation,
+  findModel,
+};

package/server/utils/omit-deep.js

@@ -11,6 +11,13 @@ function omitDeep(collection, excludeKeys) {
     }
   }
 
+  if (Array.isArray(collection)) {
+    const clonedData = [];
+    for (const collectionItem of collection) {
+      clonedData.push(cloneDeepWith(collectionItem, omitFn));
+    }
+    return clonedData;
+  }
   return cloneDeepWith(collection, omitFn);
 }
 

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

@@ -3,24 +3,7 @@
 const set = require("lodash/set");
 const get = require("lodash/get");
 const resetArrayKeysDeep = require("./reset-array-keys-deep");
-
-const getAttribute = (model, attribute) => {
-  const attributeObj = model.attributes[attribute];
-  return attributeObj;
-};
-
-const isComponent = (attributeObj) => {
-  return attributeObj.type === "component";
-};
-
-const isRepeatable = (attributeObj) => {
-  return isComponent(attributeObj) && !!attributeObj.repeatable;
-};
-
-const findModel = (models, uid) => {
-  const model = models.find((model) => model.uid === uid);
-  return model;
-};
+const { getAttribute, isComponent, isDynamicZone, isRepeatable, findModel } = require("./model-utils");
 
 const parsedLocalazyEntryToCreateEntry = (
   models,
@@ -31,6 +14,7 @@ const parsedLocalazyEntryToCreateEntry = (
 ) => {
   const createEntry = {};
   const repeatableComponentsKeystoFilter = [];
+  const dynamicZoneComponentKeys = [];
 
   const toCreateEntry = (
     entry,
@@ -40,7 +24,8 @@ const parsedLocalazyEntryToCreateEntry = (
     key = "",
     prefix = "",
     component = "",
-    isRepeatableComponent = false
+    isRepeatableComponent = false,
+    isDZ = false,
   ) => {
     if (Array.isArray(entry)) {
       // is array
@@ -64,6 +49,33 @@ const parsedLocalazyEntryToCreateEntry = (
           if (component && !isRepeatableComponent) {
             toCreateEntry(value, model, baseEntry, `${prefix}`, `${prefix}`);
           }
+
+          if (!component && isRepeatableComponent) {
+            // used for indices filtering in dynamic zones
+            if (!repeatableComponentsKeystoFilter.includes(prefix)) {
+              repeatableComponentsKeystoFilter.push(prefix);
+            }
+            const baseEntryRepeatableItemId = parseInt(baseEntryItemId);
+            const baseEntryRepeateableGroup = get(baseEntry, prefix);
+            if (baseEntryRepeateableGroup !== undefined) {
+              const localizedEntryRepeatableItemPosition = baseEntryRepeateableGroup.findIndex((repeatableItem) => !!repeatableItem && repeatableItem.id === baseEntryRepeatableItemId);
+              if (localizedEntryRepeatableItemPosition > -1) {
+                const dzEntry = get(baseEntry, prefix).find((v) => v.id === baseEntryRepeatableItemId);
+                const dzEntryComponent = dzEntry.__component;
+                const dzEntryComponentModel = findModel(models, dzEntryComponent);
+                toCreateEntry(
+                  value,
+                  dzEntryComponentModel,
+                  baseEntry,
+                  localizedEntryRepeatableItemPosition,
+                  `${prefix}.${localizedEntryRepeatableItemPosition}`,
+                  dzEntryComponent,
+                  true,
+                  true,
+                );
+              }
+            }
+          }
         }
       });
     } else {
@@ -106,12 +118,37 @@ const parsedLocalazyEntryToCreateEntry = (
               false
             );
           }
+        } else if (isDynamicZone(attribute)) {
+          // behaves sort of like repeatable component
+          const newPrefix = prefix
+            ? `${prefix}.${objectKey}`
+            : `${objectKey}`;
+          toCreateEntry(
+            value,
+            null, // model is evaluated later as it's dynamic (DZ)
+            baseEntry,
+            objectKey,
+            newPrefix,
+            "", // component is computed later as it's dynamic (DZ)
+            true,
+            true,
+          );
         } else {
           const newPrefix = prefix ? `${prefix}.${objectKey}` : `${objectKey}`;
           set(createEntry, newPrefix, value);
 
           if (component) {
-            set(createEntry, `${prefix}.__component`, component);
+            const componentKeyToSet = `${prefix}.__component`;
+            set(createEntry, componentKeyToSet, component);
+
+            if (isDZ) {
+              const isKeyAdded = (typeof dynamicZoneComponentKeys.find((v) => v.key === componentKeyToSet) !== "undefined");
+              if (!isKeyAdded)
+                dynamicZoneComponentKeys.push({
+                  key: componentKeyToSet,
+                  component,
+                });
+            }
           }
           // is not component
         }
@@ -126,7 +163,7 @@ const parsedLocalazyEntryToCreateEntry = (
   }
 
   resetArrayKeysDeep(createEntry, repeatableComponentsKeystoFilter);
-  return createEntry;
+  return { createEntry, dynamicZoneComponentKeys };
 };
 
 module.exports = parsedLocalazyEntryToCreateEntry;

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

@@ -3,15 +3,19 @@
 const merge = require("lodash/merge");
 const parsedLocalazyEntryToCreateEntry = require("./parsed-localazy-entry-to-create-entry");
 const omitDeep = require("./omit-deep");
+const populateCreateUpdateEntryWithBaseEntry = require("./populate-create-update-entry-with-base-entry");
+const { set } = require("lodash");
 
-const parsedLocalazyEntryToUpdateEntry = (
+const parsedLocalazyEntryToUpdateEntry = async (
   allModels,
   localazyEntry,
+  fullyPopulatedLocalizedEntry,
   currentEntry,
   baseEntry,
-  uid
+  uid,
+  locale
 ) => {
-  const createEntry = parsedLocalazyEntryToCreateEntry(
+  const { createEntry, dynamicZoneComponentKeys } = parsedLocalazyEntryToCreateEntry(
     allModels,
     localazyEntry,
     baseEntry,
@@ -25,11 +29,47 @@ const parsedLocalazyEntryToUpdateEntry = (
     "locale",
     "localizations",
     "createdAt",
+    "createdBy",
     "updatedAt",
+    "updatedBy",
     "publishedAt",
   ]);
+  // set dynamic zone compoonent keys again
+  dynamicZoneComponentKeys.forEach((v) => {
+    set(updateEntry, v.key, v.component);
+  });
 
-  return updateEntry;
+  const filteredBaseEntry = omitDeep(baseEntry, [
+    // "__component", // do not omit the __component
+    "locale",
+    "localizations",
+    "createdAt",
+    "createdBy",
+    "updatedAt",
+    "updatedBy",
+    "publishedAt",
+  ]);
+  const filteredFullyPopulatedLocalizedEntry = omitDeep(fullyPopulatedLocalizedEntry, [
+    // "__component", // do not omit the __component
+    "locale",
+    "localizations",
+    "createdAt",
+    "createdBy",
+    "updatedAt",
+    "updatedBy",
+    "publishedAt",
+  ]);
+  const populatedEntry = await populateCreateUpdateEntryWithBaseEntry(
+    allModels,
+    updateEntry,
+    filteredBaseEntry,
+    filteredFullyPopulatedLocalizedEntry,
+    uid,
+    locale
+  );
+
+  // return updateEntry;
+  return populatedEntry;
 };
 
 module.exports = parsedLocalazyEntryToUpdateEntry;

package/server/utils/pick-deep.js

@@ -0,0 +1,22 @@
+"use strict";
+const isObject = require("lodash/isObject");
+const set = require("lodash/set");
+const includes = require("lodash/includes");
+
+const deepLodashPick = (obj, keys, newObj = {}, path = []) => {
+  for (let k in obj) {
+    const value = obj[k];
+
+    if (isObject(value)) {
+      path.push(k);
+      deepLodashPick(value, keys, newObj, path);
+      path.pop();
+    } else if (includes(keys, k)) {
+      set(newObj, [...path, k], value);
+    }
+  }
+
+  return newObj;
+}
+
+module.exports = deepLodashPick;

package/server/utils/pick-entries.js

@@ -1,12 +1,97 @@
 "use strict";
 
-const pickEntries = (flatten, pickPaths) => {
+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 doesPickPathsIncludeTheComponent = (pickPaths, dzParameterKey) => {
+  return pickPaths.some((pp) => pp.includes(dzParameterKey));
+}
+
+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 entryId = getDynamicZoneEntryId(key, transferSetupModel);
+    dzEntryIdComponentMap[entryId] = {
+      component: flattenComponentProps[key],
+      key: Object.keys(flattenedPickedDeep).find((fpdk) => flattenedPickedDeep[fpdk] === flattenComponentProps[key]),
+    };
+  });
+
   const pickedEntries = {};
-  Object.keys(flatten).forEach((key) => {
+  const mappedPickPaths = pickPaths.map((pickPath) => pickPath.replace(/\[\d+\]/g, ""));
+
+  // filter out "__component"
+  const filteredFlatten = Object.fromEntries(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 dzEntryId = getDynamicZoneEntryId(key, transferSetupModel);
+      const dzParameterKey = dzEntryIdComponentMap[dzEntryId].key;
+
+      if (!doesPickPathsIncludeTheComponent(pickPaths, dzParameterKey)) {
+        return;
+      }
+    }
+
     const filteredKey = key.replace(/\[\d+\]/g, "");
-    // const filteredKey = key.replace(/\d|[[\]]+/g, "");
-    if (pickPaths.includes(filteredKey)) {
-      pickedEntries[key] = flatten[key];
+    if (mappedPickPaths.includes(filteredKey)) {
+      if (isDynamicZone) {
+        const dzEntryId = getDynamicZoneEntryId(key, transferSetupModel);
+        const dzParameterKey = dzEntryIdComponentMap[dzEntryId].key;
+
+        const dzParameterName = dzParameterKey.substring(0, dzParameterKey.indexOf('['));
+        const toBeReplaced = `${dzParameterName}[${dzEntryId}]`;
+        const dzParameterComponent = dzEntryIdComponentMap[dzEntryId].component;
+        const componentAddition = `${dzParameterName}[${dzEntryId};${dzParameterComponent}]`;
+        const replacedKey = key.replace(toBeReplaced, componentAddition);
+        pickedEntries[replacedKey] = flatten[key];
+      } else {
+        pickedEntries[key] = flatten[key];
+      }
     }
   });
   return pickedEntries;