@localazy/strapi-plugin 0.2.13 → 1.0.0-beta.0

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

@@ -1,178 +0,0 @@
-"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 importFile = LocalazyUploadService.createImportFileRepresentation(
-      locale,
-      flattenContent
-    );
-    // Use `deprecate: "file"` if there is one chunk of transferred data only (99900 keys)!
-    const uploadConfig = {
-      contentOptions: {
-        type: config.LOCALAZY_DEFAULT_FILE_EXTENSION,
-      },
-      i18nOptions: { deprecate: "file" },
-      fileOptions: {
-        name: config.LOCALAZY_DEFAULT_FILE_NAME,
-        path: config.LOCALAZY_DEFAULT_FILE_PATH,
-      }
-    };
-    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/services/localazy-upload-service.js

@@ -1,52 +0,0 @@
-/* eslint-disable no-await-in-loop */
-
-"use strict";
-
-const localazyApiClientFactory = require("../utils/localazy-api-client-factory");
-
-module.exports = ({ strapi }) => ({
-  /**
-   * Upload data to Localazy.
-   * Use config to adjust the upload process.
-   * Returns status and id of a last chunk
-   */
-  async upload(file, config = {}) {
-    try {
-      const LocalazyApi = await localazyApiClientFactory();
-      const user = await strapi
-        .plugin("localazy")
-        .service("localazyUserService")
-        .getUser();
-
-      const result = await LocalazyApi.import.json({
-        project: user.project.id,
-        json: file,
-        ...config,
-      });
-
-      return {
-        success: true,
-        result,
-      };
-    } catch (e) {
-      strapi.log.error(e);
-      return {
-        success: false,
-        message: e.message,
-      };
-    }
-  },
-
-  createImportFileRepresentation(
-    sourceLang,
-    strings
-  ) {
-    const file = {
-      [sourceLang]: {
-        ...strings,
-      },
-    };
-
-    return file;
-  },
-});

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

@@ -1,29 +0,0 @@
-"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

@@ -1,53 +0,0 @@
-"use strict";
-
-const contentTransferSetupModel = require("../db/model/content-transfer-setup");
-
-const pluginSettingsModel = require("../db/model/plugin-settings");
-const getStrapiStore = require("../db/model/utils/get-strapi-store");
-
-module.exports = ({ strapi }) => ({
-  async getContentTransferSetup() {
-    const pluginStore = getStrapiStore(strapi);
-    const setup = await pluginStore.get({ key: contentTransferSetupModel.KEY });
-
-    return setup || contentTransferSetupModel.emptyContentTransferSetup;
-  },
-
-  async updateContentTransferSetup(setup) {
-    const newSetup = {
-      has_setup: true,
-      setup,
-    };
-    const pluginStore = getStrapiStore(strapi);
-    await pluginStore.set({
-      key: contentTransferSetupModel.KEY,
-      value: newSetup,
-    });
-
-    return newSetup;
-  },
-
-  async getPluginSettings() {
-    const pluginStore = getStrapiStore(strapi);
-    const settings = await pluginStore.get({ key: pluginSettingsModel.KEY });
-
-    return settings || pluginSettingsModel.emptyPluginSettings;
-  },
-
-  async updatePluginSettings(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,
-      value: newSettings,
-    });
-
-    return newSettings;
-  },
-});

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

@@ -1,151 +0,0 @@
-"use strict";
-
-const { isoLocalazyToStrapi } = require("../utils/iso-locales-utils.js");
-const intlDisplayName = require("../utils/intl-display-name.js");
-const omitDeep = require("../utils/omit-deep.js");
-const { forEach, find } = require("lodash")
-
-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);
-      let localeName = intlDisplayName(isoStrapi);
-
-      if (!localeName || !isoStrapi) {
-        throw new Error("Invalid locale");
-      }
-      localeName = `${localeName} (${isoStrapi})`;
-
-      const newLocaleCtx = { ...ctx };
-      newLocaleCtx.request.body = {
-        isDefault: false,
-        code: isoStrapi,
-        name: localeName.substring(0, 50), // limit name to 50 characters (given by Strapi)
-      };
-
-      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 {
-      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",
-        "createdAt",
-        "updatedAt",
-      ]);
-      filteredNewEntry.locale = newEntryLocale;
-      // * sets as draft (no timestamp)
-      // do not completely omit as it won't process the required fields
-      filteredNewEntry.publishedAt = null;
-
-      newLocalizationCtx.request.body = filteredNewEntry;
-
-      await contentTypeController.createLocalization(newLocalizationCtx);
-
-      const insertedEntry = await this.getEntryInLocale(
-        uid,
-        baseEntry.id,
-        newEntryLocale
-      );
-
-      return insertedEntry
-    } catch (e) {
-      strapi.log.error(e);
-      throw e;
-    }
-  },
-  async updateLocalizationForAnExistingEntry(uid, updateEntryId, data) {
-    try {
-
-      const StrapiService = strapi.plugin("localazy").service("strapiService");
-      const strapiContentTypesModels = await StrapiService.getModels();
-      const populate = await StrapiService.getPopulateObject(uid);
-
-      // Bugfix by <emanuele.c@dacoco.io>:
-      // Prevents IDs to be appended when updating a localized entry. When IDs are present
-      // Strapi attempts to update a not yet existent ID into the DB
-      if (strapiContentTypesModels) {
-        const filtered = find(strapiContentTypesModels, (model) => model.uid === uid)
-        if (filtered?.attributes) {
-          for (let attribute in filtered.attributes) {
-            if (filtered.attributes[attribute]?.type === 'dynamiczone') {
-              if (!populate[attribute] || populate[attribute] !== 'deep') {
-                populate[attribute] = 'deep'
-              }
-              forEach(data[attribute], (prop) => { if (prop?.id) delete prop.id })
-            }
-          }
-        }
-      }
-
-      const updatedEntry = await strapi.entityService.update(
-        uid,
-        updateEntryId,
-        {
-          data,
-          populate,
-        }
-      );
-
-      return updatedEntry;
-    } catch (e) {
-      strapi.log.error(e);
-      throw e;
-    }
-  },
-});

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

@@ -1,130 +0,0 @@
-"use strict";
-
-const parsedLocalazyEntryToCreateEntry = require("../utils/parsed-localazy-entry-to-create-entry");
-const parsedLocalazyEntryToUpdateEntry = require("../utils/parsed-localazy-entry-to-update-entry");
-const omitDeep = require("../utils/omit-deep");
-const { merge } = require("lodash");
-
-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 amount of recursive code's complexity is reduced
-
-
-    // Strapi i18n Service
-    const StrapiI18nService = strapi
-      .plugin("localazy")
-      .service("strapiI18nService");
-
-    const { createEntry } = parsedLocalazyEntryToCreateEntry(
-      strapiContentTypesModels,
-      translatedModel,
-      baseEntry,
-      uid,
-      isoStrapi,
-    );
-
-    const filteredBaseEntry = omitDeep(baseEntry, [
-      "locale",
-      "localizations",
-      "createdAt",
-      "createdBy",
-      "updatedAt",
-      "updatedBy",
-      "publishedAt",
-    ]);
-
-    let mergedCreateEntry = {};
-    merge(mergedCreateEntry, filteredBaseEntry, createEntry);
-    mergedCreateEntry = omitDeep(mergedCreateEntry, [
-      "locale",
-      "localizations",
-      "createdAt",
-      "createdBy",
-      "updatedAt",
-      "updatedBy",
-      "publishedAt",
-    ]);
-
-    mergedCreateEntry.locale = isoStrapi;
-    const createdEntry =
-      await StrapiI18nService.createLocalizationForAnExistingEntry(
-        ctx,
-        uid,
-        baseEntry,
-        mergedCreateEntry,
-      );
-
-    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;
-  }
-});

package/server/services/strapi-service.js

@@ -1,26 +0,0 @@
-"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);
-  },
-  async getPluginVersion() {
-    return require("../../package.json").version;
-  }
-});