@localazy/strapi-plugin 0.1.17 → 0.2.0

package/server/services/localazy-transfer-download-service.js

@@ -0,0 +1,386 @@
+"use strict";
+
+const {
+  findSetupModelByCollectionUid,
+} = require("../utils/transfer-setup-utils");
+const config = require("../config").default;
+const {
+  isoLocalazyToStrapi,
+} = require("../utils/iso-locales-utils");
+const shouldSetDownloadedProperty = require("../functions/should-set-downloaded-property");
+const set = require("lodash/set");
+const isEmpty = require("lodash/isEmpty");
+const RequestInitiatorHelper = require('../utils/request-initiator-helper');
+const PluginSettingsServiceHelper = require('../services/helpers/plugin-settings-service-helper');
+const { DOWNLOAD_EVENT, DOWNLOAD_FINISHED_EVENT } = require('../constants/events');
+
+const getFilteredLanguagesCodesForDownload = async (languagesCodes) => {
+  const pluginSettingsServiceHelper = new PluginSettingsServiceHelper(strapi);
+  const requestInitiatorHelper = new RequestInitiatorHelper(strapi);
+  await pluginSettingsServiceHelper.setup();
+  let localLanguagesCodes;
+  if (requestInitiatorHelper.isInitiatedByLocalazyWebhook()) {
+    // called by a webhook
+    localLanguagesCodes = pluginSettingsServiceHelper.getWebhookLanguagesCodes();
+  } else if (requestInitiatorHelper.isInitiatedByLocalazyPluginUI()) {
+    // called by a user from the UI
+    localLanguagesCodes = pluginSettingsServiceHelper.getUiLanguagesCodes();
+  } else {
+    strapi.log.warn("Called by an unknown initiator.");
+    return languagesCodes;
+  }
+
+  if (isEmpty(localLanguagesCodes)) {
+    return languagesCodes;
+  }
+
+  return languagesCodes.filter((code) => localLanguagesCodes.includes(code));
+};
+
+module.exports = ({ strapi }) => ({
+  async download(JobNotificationService, ctx) {
+    console.time("download");
+    strapi.log.info("Download started");
+    await JobNotificationService.emit(DOWNLOAD_EVENT, {
+      message: 'Download started',
+    });
+
+    let success = true;
+
+    // Strapi service
+    const StrapiService = strapi
+      .plugin("localazy")
+      .service("strapiService");
+
+    // Strapi i18n Service
+    const StrapiI18nService = strapi
+      .plugin("localazy")
+      .service("strapiI18nService");
+
+    const LocalazyUserService = strapi
+      .plugin("localazy")
+      .service("localazyUserService");
+    const LocalazyPubApiService = strapi
+      .plugin("localazy")
+      .service("localazyPubApiService");
+    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();
+
+    /**
+     * Get Strapi File
+     */
+    const strapiFile = await LocalazyPubApiService.getStrapiFile(
+      user.project.id
+    );
+    if (!strapiFile) {
+      success = false;
+      const message = `File ${config.LOCALAZY_DEFAULT_FILE_NAME} not found`;
+      strapi.log.error(message);
+      await JobNotificationService.emit(DOWNLOAD_FINISHED_EVENT, {
+        success,
+        message,
+      });
+      return;
+    }
+
+    /**
+     * Get Localazy Project (incl. languages)
+     */
+    const project = await LocalazyPubApiService.getProject(
+      user.project.id,
+      false,
+      true
+    );
+    if (!project) {
+      success = false;
+      const message = `Project ${user.project.id} not found`;
+      strapi.log.error(message);
+      await JobNotificationService.emit(DOWNLOAD_FINISHED_EVENT, {
+        success,
+        message,
+      });
+      return;
+    }
+
+    /**
+     * Get Localazy project languages
+     */
+    const projectLanguages = project.languages;
+    const projectSourceLanguageId = project.sourceLanguage;
+    const sourceLanguage = project.languages.find(
+      (language) => language.id === projectSourceLanguageId
+    );
+
+    if (!sourceLanguage) {
+      success = false;
+      const message = "Source language not found";
+      strapi.log.error(message);
+      await JobNotificationService.emit(DOWNLOAD_FINISHED_EVENT, {
+        success,
+        message,
+      });
+      return;
+    }
+
+    const projectSourceLanguageCode = sourceLanguage.code;
+    const projectLanguagesWithoutSourceLanguage = projectLanguages.filter(
+      (language) => language.code !== projectSourceLanguageCode
+    );
+
+    if (!projectLanguagesWithoutSourceLanguage.length) {
+      const message = "Your Localazy project is not translated to other languages.";
+      strapi.log.info(message);
+      await JobNotificationService.emit(DOWNLOAD_FINISHED_EVENT, {
+        success,
+        message,
+      });
+      return;
+    }
+
+    /**
+     * Get project languages codes
+     */
+    let languagesCodes = projectLanguagesWithoutSourceLanguage.map(
+      (language) => language.code
+    );
+    // process filtered languages only / keep all if empty!
+    languagesCodes = await getFilteredLanguagesCodesForDownload(languagesCodes);
+
+    /**
+     * Iterate over languages and create the ones that are not present in Strapi
+     */
+    const strapiUnsupportedLanguages = []; // do not iterate over these languages later
+    const strapiLocales = await StrapiI18nService.getLocales(ctx);
+    for (const isoLocalazy of languagesCodes) {
+      try {
+        const isoStrapi = isoLocalazyToStrapi(isoLocalazy);
+        const strapiLocale = strapiLocales.find(
+          (locale) => locale.code === isoStrapi
+        );
+        // skip creating locale if it already exists
+        if (strapiLocale) {
+          strapi.log.info(`The Localazy locale ${isoLocalazy} already exists.`);
+          continue;
+        }
+
+        const newLocaleCode = await StrapiI18nService.createStrapiLocale(
+          ctx,
+          isoLocalazy
+        );
+        await JobNotificationService.emit(DOWNLOAD_EVENT, {
+          message: `Created locale ${newLocaleCode}`,
+        });
+      } catch (e) {
+        strapi.log.error(e.message);
+        if (e.name === "ValidationError") {
+          // store unsupported language code
+          strapiUnsupportedLanguages.push(isoLocalazy);
+          await JobNotificationService.emit(DOWNLOAD_EVENT, {
+            message: `Language ${isoLocalazy} is not supported by Strapi`,
+          });
+        } else {
+          await JobNotificationService.emit(DOWNLOAD_EVENT, {
+            message: e.message,
+          });
+        }
+      }
+    }
+
+    /**
+     * Download all keys for Strapi-supported languages
+     */
+    const supportedLanguages = languagesCodes.filter(
+      (languageCode) => !strapiUnsupportedLanguages.includes(languageCode)
+    );
+    const localazyContent = {};
+    for (const isoLocalazy of supportedLanguages) {
+      const isoStrapi = isoLocalazyToStrapi(isoLocalazy);
+      const result = await LocalazyDownloadService.download({
+        projectId: user.project.id,
+        fileId: strapiFile.id,
+        lang: isoStrapi,
+      });
+      if (!result.success) {
+        await JobNotificationService.emit(DOWNLOAD_EVENT, {
+          message: result.message,
+        });
+      }
+      const langKeys = result.data;
+      localazyContent[isoLocalazy] = langKeys;
+    }
+
+    /**
+     * Parse Localazy content
+     */
+    const parsedLocalazyContent = {};
+    const strapiContentTypesModels = await StrapiService.getModels();
+    for (const [isoLocalazy, keys] of Object.entries(localazyContent)) {
+      const isoStrapi = isoLocalazyToStrapi(isoLocalazy);
+      if (!isoStrapi) {
+        await JobNotificationService.emit(DOWNLOAD_EVENT, {
+          message: `Language ${isoLocalazy} is not supported by Strapi`,
+        });
+        continue;
+      }
+
+      for (const localazyEntry of keys) {
+        const key = localazyEntry.key[0];
+        const value = localazyEntry.value;
+
+        const parsedKey = StrapiI18nService.parseLocalazyKey(key);
+
+        const modelContentTransferSetup = findSetupModelByCollectionUid(
+          contentTransferSetup,
+          strapiContentTypesModels,
+          parsedKey.uid
+        );
+
+        if (typeof modelContentTransferSetup !== "undefined" && shouldSetDownloadedProperty(modelContentTransferSetup, parsedKey.rest)) {
+          const parsedKeyRestWithoutComponents = parsedKey.rest;
+          const setKey = [
+            isoStrapi,
+            parsedKey.uid,
+            parsedKey.id,
+            ...parsedKeyRestWithoutComponents,
+          ];
+
+          set(parsedLocalazyContent, setKey, value);
+        }
+      }
+    }
+
+    /**
+     * Iterate over parsed Localazy content and insert/update content in Strapi
+     */
+    for (const [isoStrapi, contentTypes] of Object.entries(
+      parsedLocalazyContent
+    )) {
+      for (const [uid, models] of Object.entries(contentTypes)) {
+        /**
+         * Model could not exist anymore in Strapi
+         */
+        const strapiContentTypeModel = strapiContentTypesModels.find(
+          (model) => model.uid === uid
+        );
+        if (!strapiContentTypeModel) {
+          strapi.log.info(
+            `Model ${uid} not found in Strapi, it has been deleted, skipping...`
+          );
+          continue;
+        }
+
+        for (const [id, translatedModel] of Object.entries(models)) {
+          try {
+            /**
+             * Get original source language entry
+             */
+            const baseEntry = await strapi.entityService.findOne(uid, id, {
+              populate: "deep",
+            });
+
+            if (isEmpty(baseEntry)) {
+              const message = `Source language entry ${uid}[${id}] does not exist anymore, skipping...`;
+              throw new Error(message);
+            }
+
+            /**
+             * Get current language entry
+             */
+            const baseEntryLocalizations = baseEntry.localizations;
+
+            if (!Array.isArray(baseEntryLocalizations)) {
+              throw new Error(
+                `Content type ${uid} does not support localizations, skipping...`
+              );
+            }
+
+            const baseEntryCurrentLanguageLocalizationInfo =
+              baseEntryLocalizations.find(
+                (localization) => localization.locale === isoStrapi
+              );
+
+            if (!baseEntryCurrentLanguageLocalizationInfo) {
+              // create new entry
+              try {
+                const createdEntry = await strapiLocalazyI18nService.createEntry(
+                  ctx,
+                  uid,
+                  strapiContentTypesModels,
+                  translatedModel,
+                  baseEntry,
+                  isoStrapi,
+                );
+
+                const message = `Created new entry ${uid}[${createdEntry.id}] in language ${isoStrapi}`;
+                strapi.log.info(message);
+                await JobNotificationService.emit(DOWNLOAD_EVENT, {
+                  message,
+                });
+              } catch (e) {
+                success = false;
+                strapi.log.error(e.message);
+                strapi.log.error(JSON.stringify(e.details?.errors || {}));
+                await JobNotificationService.emit(DOWNLOAD_EVENT, {
+                  message: `Cannot create an entry in ${isoStrapi} for ${uid}[${baseEntry.id}]: ${e.message}`,
+                });
+              }
+            } else {
+              // update existing entry
+              try {
+                const localizedEntryId =
+                  baseEntryCurrentLanguageLocalizationInfo.id;
+
+                const updatedEntry = await strapiLocalazyI18nService.updateEntry(
+                  uid,
+                  localizedEntryId,
+                  strapiContentTypesModels,
+                  translatedModel,
+                  baseEntry,
+                  isoStrapi,
+                );
+
+                const message = `Updated ${uid}[${updatedEntry.id}] (${isoStrapi})`;
+                strapi.log.info(message);
+                await JobNotificationService.emit(DOWNLOAD_EVENT, {
+                  message,
+                });
+              } catch (e) {
+                success = false;
+                strapi.log.error(e.message);
+                strapi.log.error(JSON.stringify(e.details?.errors || {}));
+                await JobNotificationService.emit(DOWNLOAD_EVENT, {
+                  message: `Cannot update an ${uid}[${baseEntryCurrentLanguageLocalizationInfo.id}] (${isoStrapi}): ${e.message}`,
+                });
+              }
+            }
+          } catch (e) {
+            success = false;
+            strapi.log.error(e.message);
+            await JobNotificationService.emit(DOWNLOAD_FINISHED_EVENT, {
+              success,
+              message: `An error occured while processing download: ${e.message}`,
+            });
+          }
+        }
+      }
+    }
+
+    strapi.log.info("Download finished in");
+    await JobNotificationService.emit(DOWNLOAD_FINISHED_EVENT, {
+      success,
+      message: 'Download finished',
+    });
+    console.timeEnd("download");
+  },
+});

package/server/services/localazy-transfer-upload-service.js

@@ -0,0 +1,174 @@
+"use strict";
+
+const flattenObject = require("../utils/flatten-object");
+const {
+  getCollectionsNames,
+  findSetupModelByCollectionName,
+  isCollectionTransferEnabled,
+  getPickPathsWithComponents,
+} = require("../utils/transfer-setup-utils");
+const pickEntries = require("../utils/pick-entries");
+const config = require("../config").default;
+const {
+  isoStrapiToLocalazy,
+} = require("../utils/iso-locales-utils");
+const omitDeep = require("../utils/omit-deep");
+const { UPLOAD_EVENT, UPLOAD_FINISHED_EVENT } = require('../constants/events');
+
+module.exports = ({ strapi }) => ({
+  async upload(JobNotificationService, ctx) {
+    console.time("upload");
+    await JobNotificationService.emit(UPLOAD_EVENT, {
+      message: 'Upload started',
+    });
+
+    let success = true;
+
+    // Strapi Service
+    const StrapiService = strapi
+      .plugin("localazy")
+      .service("strapiService");
+
+    // Strapi i18n Service
+    const StrapiI18nService = strapi
+      .plugin("localazy")
+      .service("strapiI18nService");
+
+    // Localazy Upload Service
+    const LocalazyUploadService = strapi
+      .plugin("localazy")
+      .service("localazyUploadService");
+
+    // get content transfer setup
+    const contentTransferSetup = await strapi
+      .plugin("localazy")
+      .service("pluginSettingsService")
+      .getContentTransferSetup();
+
+    if (!contentTransferSetup.has_setup) {
+      const message = "Content transfer setup is not set up.";
+      success = false;
+      await JobNotificationService.emit(UPLOAD_FINISHED_EVENT, {
+        success,
+        message,
+      });
+      strapi.log.info(message);
+      return;
+    }
+
+    const { setup } = contentTransferSetup;
+    const collectionsNames = getCollectionsNames(setup);
+    const models = await StrapiService.getModels();
+    // flatten Strapi content
+    let flattenContent = {};
+
+    for (const collectionName of collectionsNames) {
+      const currentModel = models.find(
+        (model) => model.collectionName === collectionName
+      );
+      const modelUid = currentModel.uid;
+      if (!currentModel) {
+        strapi.log.warn(`Model with uid ${modelUid} is not found.`);
+        continue;
+      }
+
+      const transferSetupModel = findSetupModelByCollectionName(
+        setup,
+        collectionName
+      );
+
+      if (!isCollectionTransferEnabled(setup, collectionName)) {
+        const message = `Collection ${collectionName} transfer is disabled.`;
+        await JobNotificationService.emit(UPLOAD_EVENT, {
+          message,
+        });
+        strapi.log.info(message);
+        continue;
+      }
+
+      // get only enabled fields paths
+      const currentTransferSetupModel = transferSetupModel[collectionName];
+      const pickPaths = getPickPathsWithComponents(currentTransferSetupModel);
+      if (!pickPaths.length) {
+        const message = `No fields for collection ${collectionName} transfer are enabled.`;
+        await JobNotificationService.emit(UPLOAD_EVENT, {
+          message,
+        });
+        strapi.log.warn(message);
+        continue;
+      }
+      const pickPathsWithUid = pickPaths.map(
+        (pickPath) => `${modelUid}.${pickPath}`
+      );
+
+      let entries = await strapi.entityService.findMany(modelUid, {
+        populate: "deep",
+      });
+      entries = omitDeep(entries, [
+        // "__component",
+        "locale",
+        "localizations",
+        "createdAt",
+        "createdBy",
+        "updatedAt",
+        "updatedBy",
+        "publishedAt",
+      ]);
+
+      if (!entries) {
+        strapi.log.info(`No entries found for model ${modelUid}`);
+        continue;
+      }
+
+      if (!Array.isArray(entries)) {
+        entries = [entries];
+      }
+
+      entries.forEach((entry) => {
+        const flatten = flattenObject({
+          [modelUid]: entry,
+        });
+        // get only enabled fields; "__component" will be filtered out inside of the function
+        const pickedFlatten = pickEntries(flatten, pickPathsWithUid);
+
+        flattenContent = {
+          ...flattenContent,
+          ...pickedFlatten,
+        };
+      });
+    }
+
+    // get Strapi default language and convert it to Localazy language code
+    const strapiLocales = await StrapiI18nService.getLocales(ctx);
+    const defaultLocale = strapiLocales.find((locale) => locale.isDefault);
+
+    const locale = defaultLocale
+      ? isoStrapiToLocalazy(defaultLocale.code)
+      : config.LOCALAZY_DEFAULT_LOCALE;
+
+    const chunks = LocalazyUploadService.splitToChunks(flattenContent);
+    const importFile = LocalazyUploadService.createImportFileRepresentation(
+      config.LOCALAZY_DEFAULT_FILE_NAME,
+      config.LOCALAZY_DEFAULT_FILE_PATH,
+      config.LOCALAZY_DEFAULT_FILE_EXTENSION,
+      locale,
+      chunks
+    );
+    // Use `deprecate: "file"` if there is one chunk of transferred data only!
+    const hasMoreTransferFilesChunks = importFile.length > 1;
+    const uploadConfig = !hasMoreTransferFilesChunks ? { deprecate: "file" } : {};
+    await JobNotificationService.emit(UPLOAD_EVENT, {
+      message: "Uploading collections to Localazy...",
+    });
+    await LocalazyUploadService.upload(
+      importFile,
+      uploadConfig
+    );
+    strapi.log.info("Upload finished in");
+    await JobNotificationService.emit(UPLOAD_FINISHED_EVENT, {
+      success,
+      message: "Upload finished",
+    });
+    console.timeEnd("upload");
+  },
+});

package/server/utils/generate-random-id.js

@@ -0,0 +1,3 @@
+const generateRandomId = (length = 16) => `_${Math.random().toString(36).substr(2, length)}`;
+
+module.exports = generateRandomId;

package/server/utils/pick-entries.js

@@ -1,7 +1,7 @@
 "use strict";
 
 const isDynamicZoneKey = (key) => {
-  const matches = key.match(/\[\d+;\w+\./g);
+  const matches = key.match(/\[\d+;[\w-]+\./g);
   return matches !== null;
 };
 
@@ -20,7 +20,7 @@ const pickEntries = (flatten, pickPaths) => {
     let filteredKey = key;
     filteredKey = filteredKey.replace(/\[\d+\]/g, "");
     if (isDynamicZoneKey(key)) {
-      filteredKey = filteredKey.replace(/\[\d+;\w+\./g, `[`);
+      filteredKey = filteredKey.replace(/\[\d+;[\w-]+\./g, `[`);
     }
     if (mappedPickPaths.includes(filteredKey)) {
       pickedEntries[key] = flatten[key];