@localazy/strapi-plugin 0.1.12 → 0.1.13-rc.0

package/server/bootstrap.js

@@ -1,19 +1,60 @@
 "use strict";
 
-const getFullPopulateObject = require('./utils/get-full-populate-object')
+const deepPopulateHook = require('./lifecycles/deep-populate-hook');
+const uploadEventEntryToLocalazyHook = require('./lifecycles/upload-event-entry-to-localazy-hook');
+const deprecateEventEntryInLocalazyHook = require('./lifecycles/deprecate-event-entry-in-localazy-hook');
+const RequestInitiatorHelper = require('./utils/request-initiator-helper');
 
 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;
+  // Subscribe to the lifecycles that we are interested in.
+  strapi.db.lifecycles.subscribe(async (event) => {
+    const requestInitiatorHelper = new RequestInitiatorHelper(strapi);
+    const action = event.action;
+    switch (action) {
+      case 'beforeFindMany':
+      case 'beforeFindOne': {
+        deepPopulateHook(event);
+        break;
+      }
+      case 'afterCreate':
+      case 'afterUpdate': {
+        try {
+          if (requestInitiatorHelper.isInitiatedByLocalazyWebhook() || requestInitiatorHelper.isInitiatedByLocalazyPluginUI()) {
+            break;
+          }
+
+          uploadEventEntryToLocalazyHook(event).then((result) => {
+            if (typeof result !== 'undefined') {
+              strapi.log.info(`${action} hook result: ${JSON.stringify(result)}`);
+            }
+          });
+        } catch (e) {
+          strapi.log.error(e);
+        } finally {
+          break;
+        }
+      }
+      case 'beforeDeleteMany':
+      case 'beforeDelete': {
+        try {
+          if (requestInitiatorHelper.isInitiatedByLocalazyWebhook() || requestInitiatorHelper.isInitiatedByLocalazyPluginUI()) {
+            break;
+          }
 
-      if (populate && populate[0] === 'deep') {
-        const depth = populate[1] ?? 5
-        const modelObject = getFullPopulateObject(event.model.uid, depth);
-        event.params.populate = modelObject.populate
+          // have to await here
+          const result = await deprecateEventEntryInLocalazyHook(event);
+          if (typeof result !== 'undefined') {
+            strapi.log.info(`${action} hook result: ${JSON.stringify(result)}`);
+          }
+        } catch (e) {
+          strapi.log.error(e);
+        } finally {
+          break;
+        }
       }
+      default:
+        break;
     }
   });
 };

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

@@ -18,6 +18,31 @@ const shouldSetDownloadedProperty = require("../functions/should-set-downloaded-
 const set = require("lodash/set");
 const isEmpty = require("lodash/isEmpty");
 const omitDeep = require("../utils/omit-deep");
+const RequestInitiatorHelper = require('../utils/request-initiator-helper');
+const PluginSettingsServiceHelper = require('../services/helpers/plugin-settings-service-helper');
+
+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 = {
   async upload(ctx) {
@@ -152,7 +177,11 @@ module.exports = {
         locale,
         chunks
       );
-      await LocalazyUploadService.upload(importFile);
+      await LocalazyUploadService.upload(
+        importFile,
+        {
+          deprecate: "file"
+        });
 
       ctx.body = {
         success,
@@ -205,8 +234,15 @@ module.exports = {
       user.project.id
     );
     if (!strapiFile) {
-      strapi.log.error(`File ${config.LOCALAZY_DEFAULT_FILE_NAME} not found`);
-      ctx.throw(400, `File ${config.LOCALAZY_DEFAULT_FILE_NAME} not found`);
+      success = false;
+      const message = `File ${config.LOCALAZY_DEFAULT_FILE_NAME} not found`;
+      strapi.log.error(message);
+      messageReport.push(message);
+      ctx.body = {
+        success,
+        report: messageReport,
+      };
+      return;
     }
 
     /**
@@ -269,9 +305,11 @@ module.exports = {
     /**
      * Get project languages codes
      */
-    const languagesCodes = projectLanguagesWithoutSourceLanguage.map(
+    let languagesCodes = projectLanguagesWithoutSourceLanguage.map(
       (language) => language.code
     );
+    // process filtered languages only / keep all of empty!
+    languagesCodes = await getFilteredLanguagesCodesForDownload(languagesCodes);
 
     /**
      * Iterate over languages and create the ones that are not present in Strapi

package/server/controllers/strapi-controller.js

@@ -13,4 +13,7 @@ module.exports = {
       .service("strapiService")
       .getLocalizableModels();
   },
+  async postLifecycleLocalazyWebhooks(ctx) {
+    strapi.log("done");
+  },
 };

package/server/lifecycles/deep-populate-hook.js

@@ -0,0 +1,11 @@
+const getFullPopulateObject = require('../utils/get-full-populate-object');
+
+module.exports = (event) => {
+  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/lifecycles/deprecate-event-entry-in-localazy-hook.js

@@ -0,0 +1,69 @@
+"use strict";
+
+const getPickedFlattenKeysForHookEntry = require('../utils/get-picked-flatten-keys-for-hook-entry');
+const config = require("../config").default;
+const getLocalazyApi = require("../utils/get-localazy-api");
+const delay = require("../utils/delay");
+
+module.exports = async (event) => {
+  const pickedFlattedResult = await getPickedFlattenKeysForHookEntry(event);
+
+  if (typeof pickedFlattedResult === "undefined") {
+    return;
+  }
+
+  const { pickedFlatten, eventEntryLocale } = pickedFlattedResult;
+
+  const LocalazyUserService = strapi
+    .plugin("localazy")
+    .service("localazyUserService");
+  const LocalazyPubApiService = strapi
+    .plugin("localazy")
+    .service("localazyPubApiService");
+  const LocalazyDownloadService = strapi
+    .plugin("localazy")
+    .service("localazyDownloadService");
+
+  const user = await LocalazyUserService.getUser();
+
+  /**
+   * Get Strapi File
+   */
+  const strapiFile = await LocalazyPubApiService.getStrapiFile(
+    user.project.id
+  );
+  if (!strapiFile) {
+    strapi.log.error(`File ${config.LOCALAZY_DEFAULT_FILE_NAME} not found`);
+    return;
+  }
+
+  const projectKeys = await LocalazyDownloadService.download({
+    projectId: user.project.id,
+    fileId: strapiFile.id,
+    lang: eventEntryLocale,
+  });
+
+  const pickedFlattenKeys = Object.keys(pickedFlatten);
+  const filteredProjectKeysIds = projectKeys.data
+    .filter((key) => pickedFlattenKeys.includes(key.key[0]))
+    .map((key) => key.id);
+
+  const LocalazyApi = await getLocalazyApi();
+  // call in a loop in a sequence, to avoid hitting PubAPI limits
+  for (const filteredProjectKeysId of filteredProjectKeysIds) {
+    try {
+      await LocalazyApi.updateKey({
+        projectId: user.project.id,
+        keyId: filteredProjectKeysId,
+        deprecated: 0,
+      });
+      await delay();
+    } catch (e) {
+      strapi.log.error(e.message);
+    }
+  }
+
+  return {
+    success: true,
+  };
+}

package/server/lifecycles/upload-event-entry-to-localazy-hook.js

@@ -0,0 +1,31 @@
+"use strict";
+
+const getPickedFlattenKeysForHookEntry = require('../utils/get-picked-flatten-keys-for-hook-entry');
+const config = require("../config").default;
+
+module.exports = async (event) => {
+  const pickedFlattedResult = await getPickedFlattenKeysForHookEntry(event);
+
+  if (typeof pickedFlattedResult === "undefined") {
+    return;
+  }
+
+  const { pickedFlatten, eventEntryLocale } = pickedFlattedResult;
+
+  // Localazy Upload Service
+  const LocalazyUploadService = strapi
+    .plugin("localazy")
+    .service("localazyUploadService");
+
+  const chunks = LocalazyUploadService.splitToChunks(pickedFlatten);
+  const importFile = LocalazyUploadService.createImportFileRepresentation(
+    config.LOCALAZY_DEFAULT_FILE_NAME,
+    config.LOCALAZY_DEFAULT_FILE_PATH,
+    config.LOCALAZY_DEFAULT_FILE_EXTENSION,
+    eventEntryLocale,
+    chunks
+  );
+
+  const result = await LocalazyUploadService.upload(importFile);
+  return result;
+}

package/server/middlewares/index.js

@@ -1,3 +1,7 @@
 "use strict";
 
-module.exports = {};
+const verifyWebhook = require("./verify-webhook");
+
+module.exports = {
+  verifyWebhook
+};

package/server/middlewares/verify-webhook.js

@@ -0,0 +1,77 @@
+"use strict";
+
+const crypto = require("crypto");
+const PluginSettingsServiceHelper = require('../services/helpers/plugin-settings-service-helper');
+
+module.exports = (config, { strapi }) => {
+  return async (ctx, next) => {
+    try {
+      const pluginSettingsServiceHelper = new PluginSettingsServiceHelper(strapi);
+      await pluginSettingsServiceHelper.setup();
+
+      if (!pluginSettingsServiceHelper.shouldAllowWebhookDownloadProcess()) {
+        throw new Error("Localazy Plugin: Webhook download process is disabled; terminating execution");
+      }
+
+      const requestBody = ctx.request.body;
+      strapi.log.info(`Localazy Plugin: Webhook of type '${requestBody.type}' procedure started`);
+
+      const LocalazyPubApiService = strapi
+        .plugin("localazy")
+        .service("localazyPubApiService");
+      const LocalazyUserService = strapi
+        .plugin("localazy")
+        .service("localazyUserService");
+      const user = await LocalazyUserService.getUser();
+
+      const result = await LocalazyPubApiService.getWebhooksSecret(user.project.id);
+
+      const { secret } = result;
+      const xLocalazyHmac = ctx.request.header["x-localazy-hmac"];
+      const xLocalazyTimestamp = ctx.request.header["x-localazy-timestamp"];
+
+      // if older than 15 mins - do not process
+      const THRESHOLD = 900000; // 15 mins = 900000ms
+
+      const intXLocalazyTimestamp = parseInt(xLocalazyTimestamp);
+      if (Number.isNaN(intXLocalazyTimestamp)) {
+        throw new Error("Localazy Plugin: Webhook request invalid timestamp provided; terminating execution");
+      }
+
+      if ((intXLocalazyTimestamp * 1000 + THRESHOLD) < Date.now()) {
+        throw new Error("Localazy Plugin: Webhook request is older than threshold; terminating execution");
+      }
+
+      const strapiHmac = crypto.createHmac("sha256", secret);
+      const signedMessage = strapiHmac.update(`${xLocalazyTimestamp}-${JSON.stringify(requestBody)}`).digest("hex");
+
+      if (xLocalazyHmac !== signedMessage) {
+        throw new Error("Localazy Plugin: Webhook verification did not pass; terminating execution");
+      }
+
+      /**
+       * When further actions are called by a webhook, then there's no user assigned to the operation
+       * It's needed to assign the user ID to the operation (requested e.g. for adding a new locale)
+       */
+      if (!ctx.state.user) {
+        const webhookAuthorId = pluginSettingsServiceHelper.getWebhookAuthorId();
+        if (Number.isNaN(webhookAuthorId)) {
+          throw new Error("Localazy Plugin: Webhook author is not set; terminating execution");
+        }
+        ctx.state.user = {
+          id: webhookAuthorId,
+        };
+      }
+
+      await next(); // proceed with the request; await for the response
+
+      strapi.log.info(`Localazy Plugin: Webhook of type '${requestBody.type}' procedure finished`);
+    } catch (e) {
+      strapi.log.warn(e.message);
+      ctx.body = {
+        success: false,
+        message: e.message,
+      };
+    }
+  }
+}

package/server/routes/index.js

@@ -6,6 +6,7 @@ const pluginSettingsRoutes = require("./plugin-settings");
 const strapiRoutes = require("./strapi");
 const localazyTransferRoutes = require("./localazy-transfer");
 const localazyProjectRoutes = require("./localazy-project");
+const localazyPublicTransferRoutes = require("./localazy-public-transfer");
 
 module.exports = {
   "content-api": {
@@ -23,4 +24,5 @@ module.exports = {
       ...localazyProjectRoutes,
     ],
   },
+  localazyPublicTransferRoutes,
 };

package/server/routes/localazy-public-transfer.js

@@ -0,0 +1,20 @@
+"use strict";
+
+const ROUTE_PREFIX = "/public/transfer";
+
+module.exports = {
+  routes: [
+    {
+      method: "POST",
+      path: `${ROUTE_PREFIX}/download`,
+      handler: "localazyTransferController.download",
+      config: {
+        policies: [],
+        auth: false, // make the route public
+        middlewares: [
+          "plugin::localazy.verifyWebhook"
+        ]
+      },
+    },
+  ]
+};

package/server/routes/strapi.js

@@ -19,4 +19,12 @@ module.exports = [
       policies: [],
     },
   },
+  {
+    method: "POST",
+    path: `${ROUTE_PREFIX}/lifecycle/localazy-webhooks`,
+    handler: "strapiController.postLifecycleLocalazyWebhooks",
+    config: {
+      policies: [],
+    },
+  },
 ];

package/server/services/helpers/plugin-settings-service-helper.js

@@ -0,0 +1,52 @@
+"use strict";
+
+class PluginSettingsServiceHelper {
+  constructor(strapi) {
+    this.strapi = strapi;
+    this.pluginSettingsService = strapi.plugin("localazy").service("pluginSettingsService");
+  }
+
+  async setup() {
+    this.pluginSettings = await this.pluginSettingsService.getPluginSettings();
+  }
+
+  shouldAllowAutomatedUpload() {
+    return typeof this.pluginSettings?.upload?.allowAutomated === "boolean" ? this.pluginSettings.upload.allowAutomated : false;
+  }
+
+  shouldAllowAutomatedCreatedTrigger() {
+    const automatedTriggers = this.getAutomatedUploadTriggers();
+    return this.shouldAllowAutomatedUpload() && automatedTriggers.includes("created");
+  }
+
+  shouldAllowAutomatedUpdatedTrigger() {
+    const automatedTriggers = this.getAutomatedUploadTriggers();
+    return this.shouldAllowAutomatedUpload() && automatedTriggers.includes("updated");
+  }
+
+  getAutomatedUploadTriggers() {
+    return this.pluginSettings?.upload?.automatedTriggers || [];
+  }
+
+  shouldAllowDeprecateOnDeletion() {
+    return typeof this.pluginSettings?.upload?.allowDeprecate === "boolean" ? this.pluginSettings.upload.allowDeprecate : false;
+  }
+
+  shouldAllowWebhookDownloadProcess() {
+    return typeof this.pluginSettings?.download?.processDownloadWebhook === "boolean" ? this.pluginSettings.download.processDownloadWebhook : true;
+  }
+
+  getWebhookAuthorId() {
+    return this.pluginSettings?.download?.webhookAuthorId || null;
+  }
+
+  getWebhookLanguagesCodes() {
+    return this.pluginSettings?.download?.webhookLanguages || [];
+  }
+
+  getUiLanguagesCodes() {
+    return this.pluginSettings?.download?.uiLanguages || [];
+  }
+}
+
+module.exports = PluginSettingsServiceHelper;

package/server/services/localazy-pubapi-service.js

@@ -44,4 +44,10 @@ module.exports = ({ strapi }) => ({
 
     return projects.find((project) => project.id === projectId);
   },
+  async getWebhooksSecret(projectId) {
+    const LocalazyApi = await getLocalazyApi();
+    const result = await LocalazyApi.getWebhooksSecret({ projectId });
+
+    return result;
+  }
 });

package/server/services/plugin-settings-service.js

@@ -39,7 +39,13 @@ module.exports = ({ strapi }) => ({
   },
 
   async updatePluginSettings(settings) {
-    const newSettings = settings;
+    const currentSettings = await this.getPluginSettings();
+
+    // keep the current settings if the new settings are not provided
+    const newSettings = {
+      ...currentSettings,
+      ...settings,
+    };
     const pluginStore = getStrapiStore(strapi);
     await pluginStore.set({
       key: pluginSettingsModel.KEY,

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

@@ -7,7 +7,7 @@ const cloneDeep = require("lodash/cloneDeep");
 const omitDeep = require("../utils/omit-deep.js");
 
 module.exports = ({ strapi }) => ({
-  async getLocales(ctx) {
+  async getLocales(ctx = {}) {
     await strapi.controller("plugin::i18n.locales").listLocales(ctx);
     return ctx.body;
   },