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

package/admin/src/modules/plugin-settings/components/ContentTransferSetup/index.js

@@ -111,6 +111,11 @@ function ContentTransferSetup() {
 
       const newState = cloneDeep(prevState);
       keys.forEach((key) => {
+        // * if there's a "__component__" in the key; skip
+        if (key.includes("__component__")) {
+          return;
+        }
+
         const isEditable = get(model, key) !== null;
 
         if (isEditable) {

package/admin/src/modules/plugin-settings/components/Tree/index.js

@@ -1,8 +1,10 @@
 import React, { useState, useEffect } from "react";
 import PropTypes from "prop-types";
 import { Box } from "@strapi/design-system/Box";
+import { Flex } from "@strapi/design-system/Flex";
 import { Switch } from '@strapi/design-system/Switch';
 import { Checkbox } from '@strapi/design-system/Checkbox';
+import DynamicZone from '@strapi/icons/DynamicZone';
 import { Accordion, AccordionToggle, AccordionContent } from '@strapi/design-system/Accordion';
 import TreeItem from "../TreeItem";
 import flattenObject from "../../../@common/utils/functions/flatten-deep";
@@ -25,14 +27,24 @@ function Tree(props) {
         <>
           {Object.entries(branch).map(([key, value]) => {
             const isSubbranchObject = typeof value === "object" && value !== null;
-            const flattened = flattenObject(value);
+            let flattened = flattenObject(value)
+            flattened = Object.fromEntries(Object.entries(flattened).filter(([key]) => !key.includes("__component__")));
             const flattenedKeys = Object.keys(flattened).map((k) => `${path}.${key}.${k}`);
 
-            const hasTruthyValue = Object.values(flattened).some(v => v);
-            const hasFalsyValue = Object.values(flattened).some(v => !v && v !== null);
-            const hasAllNullValue = Object.values(flattened).every(v => v === null);
+            // debugger;
+            const hasTruthyValue = Object
+              .values(flattened)
+              .some(v => v);
+            const hasFalsyValue = Object
+              .values(flattened)
+              .some(v => !v && v !== null);
+            const hasAllNullValue = Object
+              .values(flattened)
+              .every(v => v === null);
 
-            if (key === "__model__") {
+            const RESERVED_KEYS_TO_SKIP = ["__model__", "__component__"];
+
+            if (RESERVED_KEYS_TO_SKIP.includes(key)) {
               return false;
             }
             const passedKey = `${path}.${key}`;
@@ -51,7 +63,10 @@ function Tree(props) {
                     indeterminate={hasTruthyValue && hasFalsyValue}
                     onChange={() => onTreeItemClick(flattenedKeys, hasTruthyValue && !hasFalsyValue)}
                   >
-                    {key || "-"}
+                    <Flex alignItems="center">
+                      {!!value?.__component__ && (<Flex alignItems="center" marginRight={2}><DynamicZone width="1rem" height="1rem" /></Flex>)}
+                      {value?.__component__ || key || "-"}
+                    </Flex>
                   </Checkbox>)
                 }
                 <TreeItem

package/admin/src/modules/plugin-settings/functions/build-content-transfer-setup-schema.js

@@ -1,6 +1,6 @@
 import set from "lodash-es/set";
 import get from "lodash-es/get";
-import deepKeys from "deep-keys";
+import deepKeys from "@david-vaclavek/deep-keys";
 import sortByModelName from "../../@common/utils/sort-by-model-name";
 import arrayOfModelsToObject from "../utils/array-of-models-to-object";
 import findModelValueByKey from "../utils/find-model-value-by-key";

package/admin/src/modules/plugin-settings/functions/has-model-changed.js

@@ -1,4 +1,4 @@
-import deepKeys from "deep-keys";
+import deepKeys from "@david-vaclavek/deep-keys";
 import get from "lodash-es/get";
 import PluginSettingsService from "../services/plugin-settings-service";
 import StrapiModelService from "../services/strapi-model-service";

package/admin/src/modules/plugin-settings/locale/en.js

@@ -1,7 +1,7 @@
 export default {
   content_transfer_setup: "Content Transfer Setup",
   content_transfer_setup_description:
-    "Setup what content type fields will be uploaded to Localazy",
+    "Select which content type fields will be uploaded to Localazy",
   save: "Save",
   cancel: "Cancel",
   close: "Close",

package/admin/src/modules/plugin-settings/utils/get-filtered-models-schemas.js

@@ -1,10 +1,4 @@
-import baseSupportedContentTypeFields from "../../@common/models/supported-content-type-fields";
-
-const SUPPORTED_CONTENT_TYPE_FIELDS = [
-  ...baseSupportedContentTypeFields,
-  "component",
-  // "relation", // relation cannot be supported field type
-];
+import SUPPORTED_CONTENT_TYPE_FIELDS from "../../@common/models/supported-content-type-fields";
 
 export default (models) => {
   if (!models) {

package/admin/src/modules/plugin-settings/utils/get-models-tree.js

@@ -28,9 +28,25 @@ const getModelsTree = (allModels, localizableModels = []) => {
               : isComponentAttributesObjectTranslatable
           ),
         };
-      } else if (
-        SUPPORTED_CONTENT_TYPE_FIELDS.includes(attributes[attribute].type)
-      ) {
+      } else if (attributes[attribute].type === "dynamiczone") {
+        const components = attributes[attribute].components;
+        currentModelTree[attribute] = [];
+        components.forEach((c) => {
+          const nestedModel = allModels.find((model) => model.uid === c);
+
+          const modelTree = getModelTree(
+            nestedModel.__schema__.attributes,
+            true,
+            isComponentAttributesObjectTranslatable === null
+              ? attributes[attribute].pluginOptions?.i18n?.localized || false
+              : isComponentAttributesObjectTranslatable
+          );
+          currentModelTree[attribute].push({
+            "__component__": c,
+            ...modelTree,
+          });
+        });
+      } else if (SUPPORTED_CONTENT_TYPE_FIELDS.includes(attributes[attribute].type)) {
         // field might not be localizable
         if (isComponentAttributes) {
           if (isComponentAttributesObjectTranslatable) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@localazy/strapi-plugin",
-  "version": "0.1.11-rc.0",
+  "version": "0.1.11-rc.1",
   "description": "The official Strapi Plugin by Localazy.",
   "strapi": {
     "name": "localazy",
@@ -27,8 +27,8 @@
     "test:watch": "jest --watch --config ./jest.config.js"
   },
   "dependencies": {
+    "@david-vaclavek/deep-keys": "^0.5.0",
     "@localazy/ts-api": "^1.0.6",
-    "deep-keys": "^0.5.0",
     "i18next": "^21.6.13",
     "isomorphic-fetch": "^3.0.0",
     "js-cookie": "^3.0.1",
@@ -39,9 +39,9 @@
     "styled-components": "^5.3.3"
   },
   "peerDependencies": {
-    "@strapi/strapi": "^4.0.0",
     "@strapi/design-system": "^1.0.0",
-    "@strapi/icons": "^1.0.0"
+    "@strapi/icons": "^1.0.0",
+    "@strapi/strapi": "^4.0.0"
   },
   "devDependencies": {
     "@babel/plugin-transform-modules-commonjs": "^7.17.7",

package/server/controllers/localazy-transfer-controller.js

@@ -17,6 +17,7 @@ const {
 const shouldSetDownloadedProperty = require("../functions/should-set-downloaded-property");
 const set = require("lodash/set");
 const isEmpty = require("lodash/isEmpty");
+const omitDeep = require("../utils/omit-deep");
 
 module.exports = {
   async upload(ctx) {
@@ -86,7 +87,8 @@ module.exports = {
         }
 
         // get only enabled fields paths
-        const pickPaths = getPickPaths(transferSetupModel[collectionName]);
+        const currentTransferSetupModel = transferSetupModel[collectionName];
+        const pickPaths = getPickPaths(currentTransferSetupModel);
         if (!pickPaths.length) {
           const message = `No fields for collection ${collectionName} transfer are enabled.`;
           messageReport.push(message);
@@ -97,11 +99,19 @@ module.exports = {
           (pickPath) => `${modelUid}.${pickPath}`
         );
 
-        const populate = await StrapiService.getPopulateObject(modelUid);
-
         let entries = await strapi.entityService.findMany(modelUid, {
-          populate,
+          populate: "deep",
         });
+        entries = omitDeep(entries, [
+          // "__component",
+          "locale",
+          "localizations",
+          "createdAt",
+          "createdBy",
+          "updatedAt",
+          "updatedBy",
+          "publishedAt",
+        ]);
 
         if (!entries) {
           strapi.log.info(`No entries found for model ${modelUid}`);
@@ -116,8 +126,8 @@ module.exports = {
           const flatten = flattenObject({
             [modelUid]: entry,
           });
-          // get only enabled fields
-          const pickedFlatten = pickEntries(flatten, pickPathsWithUid);
+          // get only enabled fields; "__component" will be filtered out inside of the function
+          const pickedFlatten = pickEntries(flatten, pickPathsWithUid, currentTransferSetupModel);
 
           flattenContent = {
             ...flattenContent,
@@ -340,11 +350,21 @@ module.exports = {
         );
 
         if (shouldSetDownloadedProperty(modelContentTransferSetup, parsedKey.rest)) {
+          const parsedKeyRestWithoutComponents = parsedKey.rest.map((segment) => {
+            const semicolonIndex = segment.indexOf(";");
+
+            if (semicolonIndex === -1) {
+              return segment;
+            }
+
+            return segment.substring(0, semicolonIndex);
+          });
+
           const setKey = [
             isoStrapi,
             parsedKey.uid,
             parsedKey.id,
-            ...parsedKey.rest,
+            ...parsedKeyRestWithoutComponents,
           ];
 
           set(parsedLocalazyContent, setKey, value);

package/server/functions/should-set-downloaded-property.js

@@ -1,5 +1,31 @@
 const get = require("lodash/get");
 
+const getDynamicZoneKeySegment = (parsedKey) => {
+  return parsedKey.find((segment) => segment.includes(";"));
+};
+
+const isDynamicZone = (parsedKey) => {
+  return !!getDynamicZoneKeySegment(parsedKey);
+};
+
+const getComponentNameFromDynamicZoneKeySegment = (dynamicZoneKeySegment) => {
+  return dynamicZoneKeySegment.split(";")[1];
+};
+
+const getDynamicZoneKeySegmentIndex = (parsedKey) => {
+  return parsedKey.findIndex((segment) => segment.includes(";"));
+}
+
+const getDynamicZonePropertyName = (parsedKey) => {
+  const dynamicZoneKeySegmentIndex = getDynamicZoneKeySegmentIndex(parsedKey);
+
+  if (dynamicZoneKeySegmentIndex === -1) {
+    return undefined;
+  }
+
+  return parsedKey[dynamicZoneKeySegmentIndex - 1];
+};
+
 const shouldSetDownloadedProperty = (
   modelContentTransferSetup,
   parsedKeyRest,
@@ -8,9 +34,28 @@ const shouldSetDownloadedProperty = (
     return false;
   }
 
-  const filteredParsedKeyRest = parsedKeyRest
-    .filter((partialKey) => isNaN(parseInt(partialKey)));
-  return !!get(modelContentTransferSetup, filteredParsedKeyRest);
+  const dynamicZoneKeySegment = getDynamicZoneKeySegment(parsedKeyRest);
+  if (!!dynamicZoneKeySegment) {
+    const dynamicZonePropertyName = getDynamicZonePropertyName(parsedKeyRest);
+    const componentName = getComponentNameFromDynamicZoneKeySegment(dynamicZoneKeySegment);
+
+    const dzContentTransferSetupModel = get(modelContentTransferSetup, dynamicZonePropertyName);
+    const dzContentTransferSetupComponentModel = dzContentTransferSetupModel.find((c) => c.__component__ === componentName);
+
+    if (!dzContentTransferSetupComponentModel) {
+      return false;
+    }
+
+    const dynamicZoneKeySegmentIndex = getDynamicZoneKeySegmentIndex(parsedKeyRest);
+    const slicedParsedKeyRest = parsedKeyRest.slice(dynamicZoneKeySegmentIndex + 1);
+    const filteredSlicedParsedKeyRest = slicedParsedKeyRest.filter((segment) => isNaN(parseInt(segment)));
+
+    return !!get(dzContentTransferSetupComponentModel, filteredSlicedParsedKeyRest);
+  } else {
+    const filteredParsedKeyRest = parsedKeyRest
+      .filter((partialKey) => isNaN(parseInt(partialKey)));
+    return !!get(modelContentTransferSetup, filteredParsedKeyRest);
+  }
 };
 
 module.exports = shouldSetDownloadedProperty;

package/server/services/strapi-i18n-service.js

@@ -39,7 +39,7 @@ module.exports = ({ strapi }) => ({
     }
   },
   parseLocalazyKey(key) {
-    const split = key.split(/\.|\[|\]/);
+    const split = key.split(/\.(?![^[]*])|\[|\]/);
     const filteredSplit = split.filter((item) => item !== "");
 
     return {

package/server/services/strapi-localazy-i18n-service.js

@@ -20,7 +20,7 @@ module.exports = ({ strapi }) => ({
       .plugin("localazy")
       .service("strapiI18nService");
 
-    const createEntry = parsedLocalazyEntryToCreateEntry(
+    const { createEntry } = parsedLocalazyEntryToCreateEntry(
       strapiContentTypesModels,
       translatedModel,
       baseEntry,