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

package/.eslintrc

@@ -1,7 +1,11 @@
 {
   // "extends": "@strapi-community",
   "env": {
-    "jest/globals": true
+    "jest/globals": true,
+    "es6": true
   },
-  "plugins": ["jest"]
+  "plugins": ["jest"],
+  "parserOptions": {
+    "ecmaVersion": "latest"
+  }
 }

package/admin/src/modules/@common/models/supported-content-type-fields.js

@@ -0,0 +1,8 @@
+const SUPPORTED_CONTENT_TYPE_FIELDS = [
+  "string",
+  "text",
+  "richtext",
+  "email",
+];
+
+export default SUPPORTED_CONTENT_TYPE_FIELDS;

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,13 +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);
+            // 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}`;
@@ -45,11 +58,15 @@ function Tree(props) {
               >
                 {isSubbranchObject && (
                   <Checkbox
+                    disabled={hasAllNullValue}
                     checked={hasTruthyValue && !hasFalsyValue}
                     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 @@
-const SUPPORTED_CONTENT_TYPE_FIELDS = [
-  "string",
-  "text",
-  "richtext",
-  // "relation", // relation cannot be supported field type
-  "component",
-];
+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

@@ -1,3 +1,5 @@
+import SUPPORTED_CONTENT_TYPE_FIELDS from "../../@common/models/supported-content-type-fields";
+
 /**
  * Supported kinds of models are expected by the function, needs to be checked before calling the function
  */
@@ -26,9 +28,25 @@ const getModelsTree = (allModels, localizableModels = []) => {
               : isComponentAttributesObjectTranslatable
           ),
         };
-      } else if (
-        ["string", "text", "richtext"].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.10",
+  "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/bootstrap.js

@@ -1,5 +1,19 @@
 "use strict";
 
-module.exports = () => {
+const getFullPopulateObject = require('./utils/get-full-populate-object')
+
+module.exports = ({ strapi }) => {
   // bootstrap phase
+  // Subscribe to the lifecycles that we are intrested in.
+  strapi.db.lifecycles.subscribe((event) => {
+    if (event.action === 'beforeFindMany' || event.action === 'beforeFindOne') {
+      const populate = event.params?.populate;
+
+      if (populate && populate[0] === 'deep') {
+        const depth = populate[1] ?? 5
+        const modelObject = getFullPopulateObject(event.model.uid, depth);
+        event.params.populate = modelObject.populate
+      }
+    }
+  });
 };

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

@@ -4,6 +4,7 @@ const flattenObject = require("../utils/flatten-object");
 const {
   getCollectionsNames,
   findSetupModelByCollectionName,
+  findSetupModelByCollectionUid,
   isCollectionTransferEnabled,
   getPickPaths,
 } = require("../utils/transfer-setup-utils");
@@ -13,11 +14,10 @@ const {
   isoLocalazyToStrapi,
   isoStrapiToLocalazy,
 } = require("../utils/iso-locales-utils");
-const parsedLocalazyEntryToCreateEntry = require("../utils/parsed-localazy-entry-to-create-entry");
-const parsedLocalazyEntryToUpdateEntry = require("../utils/parsed-localazy-entry-to-update-entry");
+const shouldSetDownloadedProperty = require("../functions/should-set-downloaded-property");
 const set = require("lodash/set");
-const merge = require("lodash/merge");
 const isEmpty = require("lodash/isEmpty");
+const omitDeep = require("../utils/omit-deep");
 
 module.exports = {
   async upload(ctx) {
@@ -87,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);
@@ -98,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}`);
@@ -117,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,
@@ -160,7 +169,9 @@ module.exports = {
     const messageReport = [];
 
     // Strapi service
-    const StrapiService = strapi.plugin("localazy").service("strapiService");
+    const StrapiService = strapi
+      .plugin("localazy")
+      .service("strapiService");
 
     // Strapi i18n Service
     const StrapiI18nService = strapi
@@ -176,6 +187,14 @@ module.exports = {
     const LocalazyDownloadService = strapi
       .plugin("localazy")
       .service("localazyDownloadService");
+    const strapiLocalazyI18nService = strapi
+      .plugin("localazy")
+      .service("strapiLocalazyI18nService");
+
+    const contentTransferSetup = await strapi
+      .plugin("localazy")
+      .service("pluginSettingsService")
+      .getContentTransferSetup();
 
     const user = await LocalazyUserService.getUser();
 
@@ -308,6 +327,7 @@ module.exports = {
      * Parse Localazy content
      */
     const parsedLocalazyContent = {};
+    const strapiContentTypesModels = await StrapiService.getModels();
     for (const [isoLocalazy, keys] of Object.entries(localazyContent)) {
       const isoStrapi = isoLocalazyToStrapi(isoLocalazy);
       if (!isoStrapi) {
@@ -322,21 +342,39 @@ module.exports = {
         const value = localazyEntry.value;
 
         const parsedKey = StrapiI18nService.parseLocalazyKey(key);
-        const setKey = [
-          isoStrapi,
-          parsedKey.uid,
-          parsedKey.id,
-          ...parsedKey.rest,
-        ];
-
-        set(parsedLocalazyContent, setKey, value);
+
+        const modelContentTransferSetup = findSetupModelByCollectionUid(
+          contentTransferSetup,
+          strapiContentTypesModels,
+          parsedKey.uid
+        );
+
+        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,
+            ...parsedKeyRestWithoutComponents,
+          ];
+
+          set(parsedLocalazyContent, setKey, value);
+        }
       }
     }
 
     /**
      * Iterate over parsed Localazy content and insert/update content in Strapi
      */
-    const strapiContentTypesModels = await StrapiService.getModels();
     for (const [isoStrapi, contentTypes] of Object.entries(
       parsedLocalazyContent
     )) {
@@ -359,14 +397,9 @@ module.exports = {
             /**
              * Get original source language entry
              */
-            const populate = await StrapiService.getPopulateObject(uid);
-            const baseEntryDeep = await strapi.entityService.findOne(uid, id, {
-              populate,
-            });
-            let baseEntry = await strapi.entityService.findOne(uid, id, {
-              populate: "*",
+            const baseEntry = await strapi.entityService.findOne(uid, id, {
+              populate: "deep",
             });
-            baseEntry = merge(baseEntry, baseEntryDeep);
 
             if (isEmpty(baseEntry)) {
               const message = `Source language entry ${uid}[${id}] does not exist anymore, skipping...`;
@@ -392,20 +425,15 @@ module.exports = {
             if (!baseEntryCurrentLanguageLocalizationInfo) {
               // create new entry
               try {
-                const createEntry = parsedLocalazyEntryToCreateEntry(
+                const createdEntry = await strapiLocalazyI18nService.createEntry(
+                  ctx,
+                  uid,
                   strapiContentTypesModels,
                   translatedModel,
                   baseEntry,
-                  uid,
-                  isoStrapi
+                  isoStrapi,
                 );
-                const createdEntry =
-                  await StrapiI18nService.createLocalizationForAnExistingEntry(
-                    ctx,
-                    uid,
-                    baseEntry,
-                    createEntry
-                  );
+
                 messageReport.push(
                   `Created new entry ${uid}[${createdEntry.id}] in language ${isoStrapi}`
                 );
@@ -421,29 +449,16 @@ module.exports = {
               try {
                 const localizedEntryId =
                   baseEntryCurrentLanguageLocalizationInfo.id;
-                const populate = await StrapiService.getPopulateObject(uid);
-                const localizedEntry = await strapi.entityService.findOne(
+
+                const updatedEntry = await strapiLocalazyI18nService.updateEntry(
                   uid,
                   localizedEntryId,
-                  {
-                    populate,
-                  }
-                );
-
-                const updateEntry = parsedLocalazyEntryToUpdateEntry(
                   strapiContentTypesModels,
                   translatedModel,
-                  localizedEntry,
                   baseEntry,
-                  uid
+                  isoStrapi,
                 );
 
-                const updatedEntry =
-                  await StrapiI18nService.updateLocalizationForAnExistingEntry(
-                    uid,
-                    localizedEntryId,
-                    updateEntry
-                  );
                 messageReport.push(
                   `Updated ${uid}[${updatedEntry.id}] (${isoStrapi})`
                 );

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

@@ -0,0 +1,61 @@
+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,
+) => {
+  if (!modelContentTransferSetup.__model__) {
+    return false;
+  }
+
+  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/models/supported-content-type-fields.js

@@ -0,0 +1,8 @@
+const SUPPORTED_CONTENT_TYPE_FIELDS = [
+  "string",
+  "text",
+  "richtext",
+  "email",
+];
+
+module.exports = SUPPORTED_CONTENT_TYPE_FIELDS;

package/server/services/index.js

@@ -8,6 +8,7 @@ const localazyUploadService = require("./localazy-upload-service");
 const localazyDownloadService = require("./localazy-download-service");
 const localazyPubApiService = require("./localazy-pubapi-service");
 const strapiI18nService = require("./strapi-i18n-service");
+const strapiLocalazyI18nService = require("./strapi-localazy-i18n-service");
 
 module.exports = {
   localazyUserService,
@@ -18,4 +19,5 @@ module.exports = {
   localazyDownloadService,
   localazyPubApiService,
   strapiI18nService,
+  strapiLocalazyI18nService,
 };

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

@@ -3,6 +3,7 @@
 const { isoLocalazyToStrapi } = require("../utils/iso-locales-utils.js");
 const intlDisplayName = require("../utils/intl-display-name.js");
 const merge = require("lodash/merge");
+const cloneDeep = require("lodash/cloneDeep");
 const omitDeep = require("../utils/omit-deep.js");
 
 module.exports = ({ strapi }) => ({
@@ -38,7 +39,7 @@ module.exports = ({ strapi }) => ({
     }
   },
   parseLocalazyKey(key) {
-    const split = key.split(/\.|\[|\]/);
+    const split = key.split(/\.(?![^[]*])|\[|\]/);
     const filteredSplit = split.filter((item) => item !== "");
 
     return {
@@ -79,7 +80,7 @@ module.exports = ({ strapi }) => ({
       // this might not be localizable (then method is missing, skip)
       const contentTypeController = strapi.controller(uid);
       const newLocalizationCtx = { ...ctx };
-      newLocalizationCtx.is = () => false; // else throws an error in createLocalization
+      newLocalizationCtx.is = () => false; // ! else throws an error in createLocalization
       newLocalizationCtx.params.id = baseEntry.id;
 
       const newEntryLocale = newEntry.locale;
@@ -87,7 +88,7 @@ module.exports = ({ strapi }) => ({
         "locale",
         "id",
         "createdAt",
-        "publishedAt", // sets as draft (no timestamp)
+        "publishedAt", // * sets as draft (no timestamp)
         "updatedAt",
       ]);
       filteredNewEntry.locale = newEntryLocale;
@@ -101,7 +102,7 @@ module.exports = ({ strapi }) => ({
         baseEntry.id,
         newEntryLocale
       );
-      const mergedEntry = merge(baseEntry, insertedEntry);
+      const mergedEntry = merge(cloneDeep(baseEntry), insertedEntry);
 
       return mergedEntry;
     } catch (e) {

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

@@ -0,0 +1,104 @@
+"use strict";
+
+const parsedLocalazyEntryToCreateEntry = require("../utils/parsed-localazy-entry-to-create-entry");
+const parsedLocalazyEntryToUpdateEntry = require("../utils/parsed-localazy-entry-to-update-entry");
+
+module.exports = ({ strapi }) => ({
+  async createEntry(
+    ctx,
+    uid,
+    strapiContentTypesModels,
+    translatedModel,
+    baseEntry,
+    isoStrapi,
+  ) {
+    // * The entry will be created and then updated as the structures differ
+    // * It's one extra database call, but the complexity of recursive code to maintain does worth it
+
+    // Strapi i18n Service
+    const StrapiI18nService = strapi
+      .plugin("localazy")
+      .service("strapiI18nService");
+
+    const { createEntry } = parsedLocalazyEntryToCreateEntry(
+      strapiContentTypesModels,
+      translatedModel,
+      baseEntry,
+      uid,
+      isoStrapi,
+    );
+
+    const createdEntry =
+      await StrapiI18nService.createLocalizationForAnExistingEntry(
+        ctx,
+        uid,
+        baseEntry,
+        createEntry,
+      );
+
+    await this.updateEntry(
+      uid,
+      createdEntry.id,
+      strapiContentTypesModels,
+      translatedModel,
+      baseEntry,
+      isoStrapi,
+    );
+
+    return createdEntry;
+  },
+
+  async updateEntry(
+    uid,
+    localizedEntryId,
+    strapiContentTypesModels,
+    translatedModel,
+    baseEntry,
+    isoStrapi,
+  ) {
+    // Strapi Service
+    const StrapiService = strapi
+      .plugin("localazy")
+      .service("strapiService");
+
+    // Strapi i18n Service
+    const StrapiI18nService = strapi
+      .plugin("localazy")
+      .service("strapiI18nService");
+
+    const populate = await StrapiService.getPopulateObject(uid);
+    const localizedEntry = await strapi.entityService.findOne(
+      uid,
+      localizedEntryId,
+      {
+        populate,
+      }
+    );
+
+    const fullyPopulatedLocalizedEntry = await strapi.entityService.findOne(
+      uid,
+      localizedEntryId,
+      {
+        populate: "deep",
+      }
+    );
+
+    const updateEntry = await parsedLocalazyEntryToUpdateEntry(
+      strapiContentTypesModels,
+      translatedModel,
+      fullyPopulatedLocalizedEntry,
+      localizedEntry,
+      baseEntry,
+      uid,
+      isoStrapi
+    );
+
+    const updatedEntry = await StrapiI18nService.updateLocalizationForAnExistingEntry(
+      uid,
+      localizedEntryId,
+      updateEntry
+    );
+
+    return updatedEntry;
+  }
+});