@localazy/strapi-plugin 0.1.10 → 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

@@ -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, isRepeatable, findModel } = require("./model-utils");
 
 const parsedLocalazyEntryToCreateEntry = (
   models,

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

@@ -3,13 +3,16 @@
 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,
   baseEntry,
-  uid
+  uid,
+  locale
 ) => {
   const createEntry = parsedLocalazyEntryToCreateEntry(
     allModels,
@@ -25,11 +28,43 @@ const parsedLocalazyEntryToUpdateEntry = (
     "locale",
     "localizations",
     "createdAt",
+    "createdBy",
     "updatedAt",
+    "updatedBy",
     "publishedAt",
   ]);
 
-  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/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/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,

package/server/tests/fixtures/restaurant-model.js

@@ -1,230 +0,0 @@
-module.exports = {
-  kind: "collectionType",
-  collectionName: "restaurants",
-  info: {
-    singularName: "restaurant",
-    pluralName: "restaurants",
-    displayName: "Restaurant",
-    description: "",
-  },
-  options: {
-    draftAndPublish: true,
-  },
-  pluginOptions: {
-    i18n: {
-      localized: true,
-    },
-  },
-  attributes: {
-    title: {
-      pluginOptions: {
-        i18n: {
-          localized: true,
-        },
-      },
-      type: "string",
-      required: true,
-    },
-    description: {
-      pluginOptions: {
-        i18n: {
-          localized: true,
-        },
-      },
-      type: "text",
-    },
-    books: {
-      type: "relation",
-      relation: "oneToMany",
-      target: "api::book.book",
-    },
-    recipes: {
-      type: "component",
-      repeatable: true,
-      pluginOptions: {
-        i18n: {
-          localized: true,
-        },
-      },
-      component: "food.recipe",
-    },
-    descs: {
-      type: "component",
-      repeatable: false,
-      pluginOptions: {
-        i18n: {
-          localized: true,
-        },
-      },
-      component: "food.pub-component-1",
-    },
-    street: {
-      pluginOptions: {
-        i18n: {
-          localized: true,
-        },
-      },
-      type: "string",
-    },
-    city: {
-      pluginOptions: {
-        i18n: {
-          localized: true,
-        },
-      },
-      type: "string",
-    },
-    country: {
-      pluginOptions: {
-        i18n: {
-          localized: true,
-        },
-      },
-      type: "string",
-    },
-    createdAt: {
-      type: "datetime",
-    },
-    updatedAt: {
-      type: "datetime",
-    },
-    publishedAt: {
-      type: "datetime",
-      configurable: false,
-      writable: true,
-      visible: false,
-    },
-    createdBy: {
-      type: "relation",
-      relation: "oneToOne",
-      target: "admin::user",
-      configurable: false,
-      writable: false,
-      visible: false,
-      useJoinTable: false,
-      private: true,
-    },
-    updatedBy: {
-      type: "relation",
-      relation: "oneToOne",
-      target: "admin::user",
-      configurable: false,
-      writable: false,
-      visible: false,
-      useJoinTable: false,
-      private: true,
-    },
-    localizations: {
-      writable: true,
-      private: false,
-      configurable: false,
-      visible: false,
-      type: "relation",
-      relation: "oneToMany",
-      target: "api::restaurant.restaurant",
-    },
-    locale: {
-      writable: true,
-      private: false,
-      configurable: false,
-      visible: false,
-      type: "string",
-    },
-  },
-  __schema__: {
-    collectionName: "restaurants",
-    info: {
-      singularName: "restaurant",
-      pluralName: "restaurants",
-      displayName: "Restaurant",
-      description: "",
-    },
-    options: {
-      draftAndPublish: true,
-    },
-    pluginOptions: {
-      i18n: {
-        localized: true,
-      },
-    },
-    attributes: {
-      title: {
-        pluginOptions: {
-          i18n: {
-            localized: true,
-          },
-        },
-        type: "string",
-        required: true,
-      },
-      description: {
-        pluginOptions: {
-          i18n: {
-            localized: true,
-          },
-        },
-        type: "text",
-      },
-      books: {
-        type: "relation",
-        relation: "oneToMany",
-        target: "api::book.book",
-      },
-      recipes: {
-        type: "component",
-        repeatable: true,
-        pluginOptions: {
-          i18n: {
-            localized: true,
-          },
-        },
-        component: "food.recipe",
-      },
-      descs: {
-        type: "component",
-        repeatable: false,
-        pluginOptions: {
-          i18n: {
-            localized: true,
-          },
-        },
-        component: "food.pub-component-1",
-      },
-      street: {
-        pluginOptions: {
-          i18n: {
-            localized: true,
-          },
-        },
-        type: "string",
-      },
-      city: {
-        pluginOptions: {
-          i18n: {
-            localized: true,
-          },
-        },
-        type: "string",
-      },
-      country: {
-        pluginOptions: {
-          i18n: {
-            localized: true,
-          },
-        },
-        type: "string",
-      },
-    },
-    kind: "collectionType",
-  },
-  modelType: "contentType",
-  modelName: "restaurant",
-  connection: "default",
-  uid: "api::restaurant.restaurant",
-  apiName: "restaurant",
-  globalId: "Restaurant",
-  actions: {},
-  lifecycles: {},
-  singularName: "restaurant",
-  tableName: "restaurants",
-};