@localazy/strapi-plugin 0.1.9 → 0.1.11-rc.0

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,38 @@
+"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 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,
+  isRepeatable,
+  isRelation,
+  findModel,
+};

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

@@ -1,36 +1,24 @@
 "use strict";
 
 const set = require("lodash/set");
-
-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 get = require("lodash/get");
+const resetArrayKeysDeep = require("./reset-array-keys-deep");
+const { getAttribute, isComponent, isRepeatable, findModel } = require("./model-utils");
 
 const parsedLocalazyEntryToCreateEntry = (
   models,
   parsedLocalazyEntry,
+  baseEntry,
   uid,
   locale = ""
 ) => {
   const createEntry = {};
+  const repeatableComponentsKeystoFilter = [];
 
   const toCreateEntry = (
     entry,
     model,
+    baseEntry,
     // eslint-disable-next-line no-unused-vars
     key = "",
     prefix = "",
@@ -39,16 +27,25 @@ const parsedLocalazyEntryToCreateEntry = (
   ) => {
     if (Array.isArray(entry)) {
       // is array
-      let i = 0;
-      Object.entries(entry).forEach(([, value]) => {
+      Object.entries(entry).forEach(([baseEntryItemId, value]) => {
         if (value !== null) {
           if (component && isRepeatableComponent) {
-            toCreateEntry(value, model, i, `${prefix}.${i}`, component);
-            i += 1;
+            // used for indices filtering in repeatable components
+            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) {
+                toCreateEntry(value, model, baseEntry, localizedEntryRepeatableItemPosition, `${prefix}.${localizedEntryRepeatableItemPosition}`, component);
+              }
+            }
           }
 
           if (component && !isRepeatableComponent) {
-            toCreateEntry(value, model, `${prefix}`, `${prefix}`);
+            toCreateEntry(value, model, baseEntry, `${prefix}`, `${prefix}`);
           }
         }
       });
@@ -70,6 +67,7 @@ const parsedLocalazyEntryToCreateEntry = (
             toCreateEntry(
               value,
               componentModel,
+              baseEntry,
               objectKey,
               newPrefix,
               component,
@@ -84,6 +82,7 @@ const parsedLocalazyEntryToCreateEntry = (
             toCreateEntry(
               value,
               componentModel,
+              baseEntry,
               objectKey,
               newPrefix,
               component,
@@ -104,11 +103,12 @@ const parsedLocalazyEntryToCreateEntry = (
   };
 
   const model = findModel(models, uid);
-  toCreateEntry(parsedLocalazyEntry, model);
+  toCreateEntry(parsedLocalazyEntry, model, baseEntry);
   if (locale) {
     createEntry.locale = locale;
   }
 
+  resetArrayKeysDeep(createEntry, repeatableComponentsKeystoFilter);
   return createEntry;
 };
 

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

@@ -3,29 +3,68 @@
 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 parsedLocalazyEntryToUpdateEntry = (
+const parsedLocalazyEntryToUpdateEntry = async (
   allModels,
   localazyEntry,
+  fullyPopulatedLocalizedEntry,
   currentEntry,
-  uid
+  baseEntry,
+  uid,
+  locale
 ) => {
   const createEntry = parsedLocalazyEntryToCreateEntry(
     allModels,
     localazyEntry,
+    baseEntry,
     uid
   );
-  let updateEntry = merge(currentEntry, createEntry);
+
+  let updateEntry = {};
+  merge(updateEntry, currentEntry, createEntry);
   updateEntry = omitDeep(updateEntry, [
     "__component",
     "locale",
     "localizations",
     "createdAt",
+    "createdBy",
+    "updatedAt",
+    "updatedBy",
+    "publishedAt",
+  ]);
+
+  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 updateEntry;
+  return populatedEntry;
 };
 
 module.exports = parsedLocalazyEntryToUpdateEntry;

package/server/utils/pick-entries.js

@@ -3,7 +3,8 @@
 const pickEntries = (flatten, pickPaths) => {
   const pickedEntries = {};
   Object.keys(flatten).forEach((key) => {
-    const filteredKey = key.replace(/\d|[[\]]+/g, "");
+    const filteredKey = key.replace(/\[\d+\]/g, "");
+    // const filteredKey = key.replace(/\d|[[\]]+/g, "");
     if (pickPaths.includes(filteredKey)) {
       pickedEntries[key] = flatten[key];
     }

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

@@ -0,0 +1,222 @@
+"use strict";
+
+const cloneDeep = require("lodash/cloneDeep");
+const set = require("lodash/set");
+const get = require("lodash/get");
+const isEmpty = require("lodash/isEmpty");
+const {
+  getAttribute,
+  isComponent,
+  isRepeatable,
+  isRelation,
+  findModel
+} = require("./model-utils");
+
+const doesExistInPopulatedLocalizedEntry = (val) => {
+  if (Array.isArray(val)) {
+    // is array
+    return !!val.length;
+  }
+
+  if (typeof val === "object") {
+    // is object
+    return !isEmpty(val);
+  }
+
+  if (val !== Object(val)) {
+    // is primitive
+    return !!val;
+  }
+}
+
+const getNewPrefix = (objectKey, prefix) => {
+  return prefix ? `${prefix}.${objectKey}` : objectKey;
+};
+
+const populateCreateUpdateEntryWithBaseEntry = async (
+  models,
+  createUpdateEntry,
+  baseEntry,
+  populatedLocalizedEntry,
+  uid,
+  locale
+) => {
+  const populatedEntry = cloneDeep(createUpdateEntry);
+
+  const populateEntry = async (
+    partialBaseEntry,
+    model,
+    objectKey = "",
+    prefix = "",
+    component = "",
+    isRepeatableComponent = false
+  ) => {
+    if (Array.isArray(partialBaseEntry)) {
+      // is array
+      const attribute = getAttribute(model, objectKey);
+
+      if (typeof attribute !== 'undefined') {
+        const newPrefix = getNewPrefix(objectKey, prefix);
+        const inCreateUpdateEntry = get(createUpdateEntry, newPrefix);
+        // TODO: decide whether add || inCreateUpdateEntry === null to the condition
+        const isMissingInCreateUpdateEntry = !!(typeof inCreateUpdateEntry === 'undefined');
+        if (isMissingInCreateUpdateEntry) {
+          const populatedLocalizedEntryVal = get(populatedLocalizedEntry, newPrefix);
+          if (doesExistInPopulatedLocalizedEntry(populatedLocalizedEntryVal)) {
+            set(populatedEntry, newPrefix, populatedLocalizedEntryVal);
+          } else {
+            set(populatedEntry, newPrefix, partialBaseEntry);
+          }
+        } else {
+          for (const [objectKey, value] of Object.entries(entry)) {
+            await populateEntry(
+              value,
+              model,
+              objectKey,
+              newPrefix
+            );
+          }
+        }
+      } else if (isRepeatableComponent) {
+        Object.entries(partialBaseEntry).forEach(async ([partialBaseEntryItemIndex, partialBaseEntryItem]) => {
+          const newPrefix = `${prefix}.${partialBaseEntryItemIndex}`;
+          await populateEntry(
+            partialBaseEntryItem,
+            model,
+            partialBaseEntryItemIndex,
+            newPrefix,
+          );
+        });
+      }
+
+    } else if (typeof partialBaseEntry === "object") {
+      // is object
+      if (partialBaseEntry === null) {
+        partialBaseEntry = {};
+      }
+
+      for (const [objectKey, value] of Object.entries(partialBaseEntry)) {
+        const attribute = getAttribute(model, objectKey);
+        if (typeof attribute === 'undefined') {
+          // skip...
+          continue;
+        } else if (isComponent(attribute)) {
+          // is component
+          const component = attribute.component;
+          const componentModel = findModel(models, component);
+
+          const newPrefix = getNewPrefix(objectKey, prefix);
+          const inCreateUpdateEntry = get(createUpdateEntry, newPrefix);
+          let isMissingInCreateUpdateEntry;
+          if (isRepeatable(attribute)) {
+            isMissingInCreateUpdateEntry = !!((typeof inCreateUpdateEntry === 'undefined') || (inCreateUpdateEntry && !inCreateUpdateEntry.length));
+          } else {
+            isMissingInCreateUpdateEntry = !!(typeof inCreateUpdateEntry === 'undefined' || inCreateUpdateEntry === null);
+          }
+
+          if (isMissingInCreateUpdateEntry) {
+            const populatedLocalizedEntryVal = get(populatedLocalizedEntry, newPrefix);
+            let valueToSet = value;
+            if (doesExistInPopulatedLocalizedEntry(populatedLocalizedEntryVal)) {
+              valueToSet = populatedLocalizedEntryVal;
+            }
+            if (isRepeatable(attribute)) {
+              valueToSet = value.map((item) => {
+                delete item.id;
+                return {
+                  __component: component,
+                  ...item,
+                };
+              });
+            } else {
+              if (!isEmpty(valueToSet)) {
+                delete valueToSet.id;
+                valueToSet.__component = component;
+              }
+            }
+            set(populatedEntry, newPrefix, valueToSet);
+          }
+          await populateEntry(
+            value,
+            componentModel,
+            objectKey,
+            newPrefix,
+            component,
+            isRepeatable(attribute),
+          );
+        } 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;
+          if (!isArray) {
+            arraiedValue = [value];
+          }
+          for (const [index, item] of Object.entries(arraiedValue)) {
+            if (!isEmpty(item)) {
+              const entityId = item.id;
+              if (!!entityId) {
+                const entryWithLocalizations = await strapi.entityService.findOne(attribute.target, entityId, {
+                  populate: ['localizations'],
+                });
+
+                const localizedEntry = entryWithLocalizations.localizations.find((item) => item.locale === locale);
+                if (!!localizedEntry && localizedEntry.id) {
+                  if (!isArray) {
+                    set(populatedEntry, newPrefix, { id: localizedEntry.id });
+                  } else {
+                    set(populatedEntry, `${newPrefix}.${index}`, { id: localizedEntry.id });
+                  }
+                }
+              }
+            }
+          }
+        } else {
+          const newPrefix = getNewPrefix(objectKey, prefix);
+          const inCreateUpdateEntry = get(createUpdateEntry, newPrefix);
+          const isMissingInCreateUpdateEntry = !!(typeof inCreateUpdateEntry === 'undefined' || inCreateUpdateEntry === null);
+          if (isMissingInCreateUpdateEntry) {
+            const populatedLocalizedEntryVal = get(populatedLocalizedEntry, newPrefix);
+            if (doesExistInPopulatedLocalizedEntry(populatedLocalizedEntryVal)) {
+              set(populatedEntry, newPrefix, populatedLocalizedEntryVal);
+            } else {
+              set(populatedEntry, newPrefix, value);
+            }
+          } else {
+            await populateEntry(
+              value,
+              model,
+              objectKey,
+              newPrefix
+            );
+          }
+        }
+      }
+    } else if (partialBaseEntry !== Object(partialBaseEntry)) {
+      // is primitive/literal
+      const attribute = getAttribute(model, objectKey);
+      if (typeof attribute !== 'undefined') {
+        const inCreateUpdateEntry = get(createUpdateEntry, prefix);
+        const isMissingInCreateUpdateEntry = !!(typeof inCreateUpdateEntry === 'undefined' || inCreateUpdateEntry === null);
+        if (isMissingInCreateUpdateEntry) {
+          set(populatedEntry, prefix, partialBaseEntry);
+        }
+      }
+    } else {
+      // ? TODO: something unknown
+      console.info(`Unknown type processed: ${partialBaseEntry}`);
+    }
+  }
+
+  const model = findModel(models, uid);
+  await populateEntry(baseEntry, model);
+
+  return populatedEntry;
+};
+
+module.exports = populateCreateUpdateEntryWithBaseEntry;

package/server/utils/reset-array-keys-deep.js

@@ -0,0 +1,19 @@
+const set = require("lodash/set");
+const get = require("lodash/get");
+
+const resetArrayKeysDeep = (object, keysToFilter) => {
+  // sort keys from deep to shallow (so we won't rewrite indices)
+  const sortedKeysToFilter = keysToFilter.sort((a, b) => {
+    const aLvl = a.match(/\./g)?.length || 0;
+    const bLvl = b.match(/\./g)?.length || 0;
+
+    return bLvl - aLvl;
+  })
+  for (const key of sortedKeysToFilter) {
+    const part = get(object, key);
+    const filteredPart = part.filter((item) => item !== undefined);
+    set(object, key, filteredPart);
+  }
+};
+
+module.exports = resetArrayKeysDeep;

package/server/utils/transfer-setup-utils.js

@@ -5,6 +5,19 @@ const findSetupModelByCollectionName = (models, collectionName) => {
   return models.find((model) => Object.keys(model)[0] === collectionName);
 };
 
+const findSetupModelByCollectionUid = (
+  contentTransferSetup,
+  strapiContentTypesModels,
+  collectionUid
+) => {
+  const currentModel = strapiContentTypesModels.find(
+    (model) => model.uid === collectionUid
+  );
+  const modelContentTransferSetup = contentTransferSetup.setup
+    .find((model) => Object.keys(model)[0] === currentModel.collectionName);
+  return modelContentTransferSetup[currentModel.collectionName];
+}
+
 const getCollectionsNames = (setup) => {
   return getMainKeysOfNestedArrayObjects(setup);
 };
@@ -33,6 +46,7 @@ const getPickPaths = (transferSetupModelProps) => {
 
 module.exports = {
   findSetupModelByCollectionName,
+  findSetupModelByCollectionUid,
   getCollectionsNames,
   isCollectionTransferEnabled,
   getPickPaths,