@localazy/strapi-plugin 0.1.0

package/server/routes/localazy-project.js

@@ -0,0 +1,14 @@
+"use strict";
+
+const ROUTE_PREFIX = "/project";
+
+module.exports = [
+  {
+    method: "GET",
+    path: `${ROUTE_PREFIX}`,
+    handler: "localazyProjectController.getConnectedProject",
+    config: {
+      policies: [],
+    },
+  },
+];

package/server/routes/localazy-transfer.js

@@ -0,0 +1,22 @@
+"use strict";
+
+const ROUTE_PREFIX = "/transfer";
+
+module.exports = [
+  {
+    method: "POST",
+    path: `${ROUTE_PREFIX}/upload`,
+    handler: "localazyTransferController.upload",
+    config: {
+      policies: [],
+    },
+  },
+  {
+    method: "POST",
+    path: `${ROUTE_PREFIX}/download`,
+    handler: "localazyTransferController.download",
+    config: {
+      policies: [],
+    },
+  },
+];

package/server/routes/localazy-user.js

@@ -0,0 +1,30 @@
+"use strict";
+
+const ROUTE_PREFIX = "/user";
+
+module.exports = [
+  {
+    method: "GET",
+    path: `${ROUTE_PREFIX}`,
+    handler: "localazyUserController.getUser",
+    config: {
+      policies: [],
+    },
+  },
+  {
+    method: "PUT",
+    path: `${ROUTE_PREFIX}`,
+    handler: "localazyUserController.updateUser",
+    config: {
+      policies: [],
+    },
+  },
+  {
+    method: "DELETE",
+    path: `${ROUTE_PREFIX}`,
+    handler: "localazyUserController.deleteUser",
+    config: {
+      policies: [],
+    },
+  },
+];

package/server/routes/plugin-settings.js

@@ -0,0 +1,22 @@
+"use strict";
+
+const ROUTE_PREFIX = "/plugin-settings";
+
+module.exports = [
+  {
+    method: "GET",
+    path: `${ROUTE_PREFIX}/content-transfer-setup`,
+    handler: "pluginSettingsController.getContentTransferSetup",
+    config: {
+      policies: [],
+    },
+  },
+  {
+    method: "PUT",
+    path: `${ROUTE_PREFIX}/content-transfer-setup`,
+    handler: "pluginSettingsController.updateContentTransferSetup",
+    config: {
+      policies: [],
+    },
+  },
+];

package/server/routes/strapi.js

@@ -0,0 +1,22 @@
+"use strict";
+
+const ROUTE_PREFIX = "/strapi";
+
+module.exports = [
+  {
+    method: "GET",
+    path: `${ROUTE_PREFIX}/models`,
+    handler: "strapiController.getModels",
+    config: {
+      policies: [],
+    },
+  },
+  {
+    method: "GET",
+    path: `${ROUTE_PREFIX}/localizable-models`,
+    handler: "strapiController.getLocalizableModels",
+    config: {
+      policies: [],
+    },
+  },
+];

package/server/services/index.js

@@ -0,0 +1,21 @@
+"use strict";
+
+const localazyUserService = require("./localazy-user-service");
+const localazyAuthService = require("./localazy-auth-service");
+const strapiService = require("./strapi-service");
+const pluginSettingsService = require("./plugin-settings-service");
+const localazyUploadService = require("./localazy-upload-service");
+const localazyDownloadService = require("./localazy-download-service");
+const localazyPubApiService = require("./localazy-pubapi-service");
+const strapiI18nService = require("./strapi-i18n-service");
+
+module.exports = {
+  localazyUserService,
+  localazyAuthService,
+  strapiService,
+  pluginSettingsService,
+  localazyUploadService,
+  localazyDownloadService,
+  localazyPubApiService,
+  strapiI18nService,
+};

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

@@ -0,0 +1,38 @@
+"use strict";
+
+const axios = require("axios");
+const config = require("../config");
+
+const ROOT_URL = config.default.LOCALAZY_PLUGIN_CONNECTOR_API_URL;
+const PLUGIN_ID = config.default.LOCALAZY_PLUGIN_ID;
+
+module.exports = (/* { strapi } */) => ({
+  async generateKeys() {
+    try {
+      const result = await axios.get(`${ROOT_URL}/public/keys`, {
+        headers: {
+          "X-Localazy-Plugin-Id": PLUGIN_ID,
+        },
+      });
+      return result.data;
+    } catch (e) {
+      throw e.data;
+    }
+  },
+
+  async completeLogin(readKey) {
+    try {
+      const result = await axios.get(
+        `${ROOT_URL}/oauth/poll?readKey=${readKey}`,
+        {
+          headers: {
+            "X-Localazy-Plugin-Id": PLUGIN_ID,
+          },
+        }
+      );
+      return result.data;
+    } catch (e) {
+      throw e.data;
+    }
+  },
+});

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

@@ -0,0 +1,54 @@
+"use strict";
+
+const getLocalazyApi = require("../utils/get-localazy-api");
+const delay = require("../utils/delay");
+
+const fetchChunkResult = async (projectId, fileId, lang, next) => {
+  try {
+    const LocalazyApi = await getLocalazyApi();
+    const chunkResult = await LocalazyApi.listKeysInFileForLanguage({
+      projectId,
+      fileId,
+      lang,
+      next,
+    });
+
+    return chunkResult;
+  } catch (e) {
+    strapi.log.error(e);
+    return {
+      keys: [],
+    };
+  }
+};
+
+module.exports = ({ strapi }) => ({
+  async download(config = {}) {
+    try {
+      const data = [];
+      let chunkResult;
+      do {
+        const next = (chunkResult && chunkResult.next) || "";
+        chunkResult = await fetchChunkResult(
+          config.projectId,
+          config.fileId,
+          config.lang,
+          next
+        );
+        await delay();
+        data.push(chunkResult);
+      } while (chunkResult.next);
+
+      return {
+        success: true,
+        data: data.map((chunk) => chunk.keys).flat(),
+      };
+    } catch (e) {
+      strapi.log.error(e);
+      return {
+        success: false,
+        message: e.message,
+      };
+    }
+  },
+});

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

@@ -0,0 +1,47 @@
+"use strict";
+
+const getLocalazyApi = require("../utils/get-localazy-api");
+const config = require("../config").default;
+
+module.exports = ({ strapi }) => ({
+  async listFiles(projectId) {
+    try {
+      const LocalazyApi = await getLocalazyApi();
+      const result = await LocalazyApi.listFiles({ projectId });
+
+      return result;
+    } catch (e) {
+      strapi.console.error(e);
+      return [];
+    }
+  },
+  async getStrapiFile(projectId) {
+    const files = await this.listFiles(projectId);
+    const strapiFile = files.find(
+      (file) =>
+        file.type === config.LOCALAZY_DEFAULT_FILE_EXTENSION &&
+        file.name === config.LOCALAZY_DEFAULT_FILE_NAME
+    );
+
+    return strapiFile;
+  },
+  async listProjects(addOrganization = true, addLanguages = true) {
+    try {
+      const LocalazyApi = await getLocalazyApi();
+      const result = await LocalazyApi.listProjects({
+        organization: addOrganization,
+        languages: addLanguages,
+      });
+
+      return result;
+    } catch (e) {
+      strapi.console.error(e);
+      return [];
+    }
+  },
+  async getProject(projectId, addOrganization = true, addLanguages = true) {
+    const projects = await this.listProjects(addOrganization, addLanguages);
+
+    return projects.find((project) => project.id === projectId);
+  },
+});

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

@@ -0,0 +1,95 @@
+/* eslint-disable no-await-in-loop */
+
+"use strict";
+
+const getLocalazyApi = require("../utils/get-localazy-api");
+const delay = require("../utils/delay");
+
+module.exports = ({ strapi }) => ({
+  /**
+   * Upload data to Localazy.
+   * Use config to adjust the upload process.
+   * Returns status and id of a last chunk
+   */
+  async upload(files, config = {}) {
+    let ret = {
+      success: false,
+      message: "No data was uploaded",
+    };
+    try {
+      for (const file of files) {
+        const LocalazyApi = await getLocalazyApi();
+        const user = await strapi
+          .plugin("localazy")
+          .service("localazyUserService")
+          .getUser();
+
+        const result = await LocalazyApi.import({
+          projectId: user.project.id,
+          files: file,
+          ...config,
+        });
+        await delay();
+        ret = {
+          success: true,
+          result: result.result,
+        };
+      }
+      return ret;
+    } catch (e) {
+      strapi.log.error(e);
+      return {
+        success: false,
+        message: e.message,
+      };
+    }
+  },
+
+  splitToChunks(data, CHUNK_LIMIT = 1000) {
+    const chunks = [];
+    const keys = Object.keys(data);
+    const keysCount = keys.length;
+    const chunksCount = Math.ceil(keysCount / CHUNK_LIMIT);
+    for (let i = 0; i < chunksCount; i += 1) {
+      const chunkStrings = {};
+      const from = CHUNK_LIMIT * i;
+      const to = CHUNK_LIMIT * (i + 1);
+
+      const currentKeys = keys.slice(from, to);
+      currentKeys.forEach((key) => {
+        chunkStrings[key] = data[key];
+      });
+      chunks.push(chunkStrings);
+    }
+
+    return chunks;
+  },
+
+  createImportFileRepresentation(
+    filename,
+    path,
+    type,
+    sourceLang,
+    stringsChunks
+  ) {
+    const files = [];
+
+    for (const strings of stringsChunks) {
+      const file = [
+        {
+          name: filename,
+          path,
+          content: {
+            type,
+            [sourceLang]: {
+              ...strings,
+            },
+          },
+        },
+      ];
+      files.push(file);
+    }
+
+    return files;
+  },
+});

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

@@ -0,0 +1,29 @@
+"use strict";
+
+const { KEY, emptyIdentity } = require("../db/model/localazy-user");
+const getStrapiStore = require("../db/model/utils/get-strapi-store");
+
+module.exports = ({ strapi }) => ({
+  async getUser() {
+    const pluginStore = getStrapiStore(strapi);
+    const user = await pluginStore.get({ key: KEY });
+
+    return user;
+  },
+
+  async updateUser(identity) {
+    const pluginStore = getStrapiStore(strapi);
+    await pluginStore.set({
+      key: KEY,
+      value: identity,
+    });
+
+    return identity;
+  },
+
+  async deleteUser() {
+    await this.updateUser(emptyIdentity);
+
+    return emptyIdentity;
+  },
+});

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

@@ -0,0 +1,30 @@
+"use strict";
+
+const {
+  KEY,
+  emptyContentTransferSetup,
+} = require("../db/model/content-transfer-setup");
+const getStrapiStore = require("../db/model/utils/get-strapi-store");
+
+module.exports = ({ strapi }) => ({
+  async getContentTransferSetup() {
+    const pluginStore = getStrapiStore(strapi);
+    const setup = await pluginStore.get({ key: KEY });
+
+    return setup || emptyContentTransferSetup;
+  },
+
+  async updateContentTransferSetup(setup) {
+    const newSetup = {
+      has_setup: true,
+      setup,
+    };
+    const pluginStore = getStrapiStore(strapi);
+    await pluginStore.set({
+      key: KEY,
+      value: newSetup,
+    });
+
+    return newSetup;
+  },
+});

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

@@ -0,0 +1,132 @@
+"use strict";
+
+const { isoLocalazyToStrapi } = require("../utils/iso-locales-utils.js");
+const intlDisplayName = require("../utils/intl-display-name.js");
+const merge = require("lodash/merge");
+const omitDeep = require("../utils/omit-deep.js");
+
+module.exports = ({ strapi }) => ({
+  async getLocales(ctx) {
+    await strapi.controller("plugin::i18n.locales").listLocales(ctx);
+    return ctx.body;
+  },
+  async createStrapiLocale(ctx, isoLocalazy) {
+    try {
+      const isoStrapi = isoLocalazyToStrapi(isoLocalazy);
+      const localeName = intlDisplayName(isoLocalazy);
+
+      if (!localeName || !isoStrapi) {
+        throw new Error("Invalid locale");
+      }
+
+      const newLocaleCtx = { ...ctx };
+      newLocaleCtx.request.body = {
+        isDefault: false,
+        code: isoStrapi,
+        name: localeName,
+      };
+
+      await strapi
+        .controller("plugin::i18n.locales")
+        .createLocale(newLocaleCtx);
+
+      return isoStrapi;
+    } catch (e) {
+      strapi.log.error(e);
+      throw e;
+    }
+  },
+  parseLocalazyKey(key) {
+    const split = key.split(/\.|\[|\]/);
+    const filteredSplit = split.filter((item) => item !== "");
+    // return split;
+
+    return {
+      uid: `${filteredSplit[0]}.${filteredSplit[1]}`,
+      id: filteredSplit[2],
+      rest: filteredSplit.slice(3),
+    };
+  },
+  async getEntryInLocale(modelUid, baseEntryId, isoStrapi, populate = "*") {
+    const StrapiService = strapi.plugin("localazy").service("strapiService");
+    const entry = await strapi.entityService.findOne(modelUid, baseEntryId, {
+      populate,
+    });
+    const localizations = entry.localizations;
+    if (entry.locale === isoStrapi) {
+      return entry;
+    }
+
+    if (Array.isArray(localizations)) {
+      const localeEntry = localizations.find(
+        (locale) => locale.locale === isoStrapi
+      );
+      if (localeEntry) {
+        const populate = await StrapiService.getPopulateObject(modelUid);
+        return this.getEntryInLocale(
+          modelUid,
+          localeEntry.id,
+          isoStrapi,
+          populate
+        );
+      }
+    }
+
+    return null;
+  },
+  async createLocalizationForAnExistingEntry(ctx, uid, baseEntry, newEntry) {
+    try {
+      // 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.params.id = baseEntry.id;
+
+      const newEntryLocale = newEntry.locale;
+      const filteredNewEntry = omitDeep(newEntry, [
+        "locale",
+        "id",
+        "createdAt",
+        "publishedAt", // sets as draft (no timestamp)
+        "updatedAt",
+      ]);
+      filteredNewEntry.locale = newEntryLocale;
+
+      newLocalizationCtx.request.body = filteredNewEntry;
+
+      await contentTypeController.createLocalization(newLocalizationCtx);
+
+      const insertedEntry = await this.getEntryInLocale(
+        uid,
+        baseEntry.id,
+        newEntryLocale
+      );
+      const mergedEntry = merge(baseEntry, insertedEntry);
+
+      return mergedEntry;
+    } catch (e) {
+      strapi.log.error(e);
+      throw e;
+    }
+  },
+  async updateLocalizationForAnExistingEntry(uid, updateEntryId, data) {
+    try {
+      const StrapiService = strapi.plugin("localazy").service("strapiService");
+      const populate = await StrapiService.getPopulateObject(uid);
+
+      const updatedEntry = await strapi.entityService.update(
+        uid,
+        updateEntryId,
+        {
+          data,
+          populate,
+        }
+      );
+
+      return updatedEntry;
+    } catch (e) {
+      strapi.log.error(e);
+      throw e;
+    }
+  },
+});

package/server/services/strapi-service.js

@@ -0,0 +1,23 @@
+"use strict";
+
+const isLocalazyApplicableContentType = require("../utils/is-localazy-applicable-content-type");
+const isGenerallyApplicableContentType = require("../utils/is-generally-applicable-content-type");
+const buildPopulate = require("../utils/build-populate");
+
+module.exports = ({ strapi }) => ({
+  // possible help source https://stackoverflow.com/questions/66180042/is-there-a-way-to-get-a-structure-of-a-strapi-cms-content-type
+  async getModels() {
+    return strapi.db.config.models.filter((model) =>
+      isGenerallyApplicableContentType(model)
+    );
+  },
+  async getLocalizableModels() {
+    return strapi.db.config.models.filter((model) =>
+      isLocalazyApplicableContentType(model)
+    );
+  },
+  async getPopulateObject(modelUid) {
+    const models = strapi.db.config.models;
+    return buildPopulate(models, modelUid);
+  },
+});