@akemona-org/strapi-plugin-i18n 3.7.0 → 3.7.2

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "3.7.0",
+  "version": "3.7.2",
   "description": "This plugin enables to create, to read and to update content in different languages, both from the Admin Panel and from the API",
   "strapi": {
     "name": "Internationalization",
@@ -12,7 +12,7 @@
     "required": false
   },
   "dependencies": {
-    "@akemona-org/strapi-utils": "3.7.0",
+    "@akemona-org/strapi-utils": "3.7.2",
     "lodash": "4.17.21",
     "p-map": "4.0.0",
     "pluralize": "8.0.0"
@@ -27,5 +27,5 @@
     "npm": ">=6.0.0"
   },
   "license": "SEE LICENSE IN LICENSE",
-  "gitHead": "129a8d6191b55810fd66448dcc47fee829df986c"
+  "gitHead": "4ab59dbae5135819558c6ae27b45a556ff27cf55"
 }

package/services/__tests__/content-types.test.js

@@ -192,121 +192,124 @@ describe('content-types service', () => {
     });
   });
 
-  describe.each([['singleType'], ['collectionType']])('getAndValidateRelatedEntity - %s', kind => {
-    test("Throw if relatedEntity is provided but doesn't exist", async () => {
-      const findOne = jest.fn(() => Promise.resolve(undefined));
-      const relatedEntityId = 1;
-      const model = 'application::country.country';
-      const locale = 'fr';
-
-      global.strapi = {
-        query: () => ({
-          findOne,
-        }),
-        getModel: () => ({ kind }),
-      };
-
-      try {
-        await getAndValidateRelatedEntity(relatedEntityId, model, locale);
-      } catch (e) {
-        expect(e.message).toBe("The related entity doesn't exist");
-      }
-
-      expect(findOne).toHaveBeenCalledWith(kind === 'singleType' ? {} : { id: relatedEntityId });
-      expect.assertions(2);
-    });
-
-    test('Throw if locale already exists (1/2)', async () => {
-      const relatedEntityId = 1;
-      const relatedEntity = {
-        id: relatedEntityId,
-        locale: 'en',
-        localizations: [],
-      };
-      const findOne = jest.fn(() => Promise.resolve(relatedEntity));
-      const model = 'application::country.country';
-      const locale = 'en';
-
-      global.strapi = {
-        query: () => ({
-          findOne,
-        }),
-        getModel: () => ({ kind }),
-      };
-
-      try {
-        await getAndValidateRelatedEntity(relatedEntityId, model, locale);
-      } catch (e) {
-        expect(e.message).toBe('The entity already exists in this locale');
-      }
-
-      expect(findOne).toHaveBeenCalledWith(kind === 'singleType' ? {} : { id: relatedEntityId });
-      expect.assertions(2);
-    });
-
-    test('Throw if locale already exists (2/2)', async () => {
-      const relatedEntityId = 1;
-      const relatedEntity = {
-        id: relatedEntityId,
-        locale: 'fr',
-        localizations: [
-          {
-            id: 2,
-            locale: 'en',
-          },
-        ],
-      };
-      const findOne = jest.fn(() => Promise.resolve(relatedEntity));
-      const model = 'application::country.country';
-      const locale = 'en';
-
-      global.strapi = {
-        query: () => ({
-          findOne,
-        }),
-        getModel: () => ({ kind }),
-      };
-
-      try {
-        await getAndValidateRelatedEntity(relatedEntityId, model, locale);
-      } catch (e) {
-        expect(e.message).toBe('The entity already exists in this locale');
-      }
-
-      expect(findOne).toHaveBeenCalledWith(kind === 'singleType' ? {} : { id: relatedEntityId });
-      expect.assertions(2);
-    });
-
-    test('get related entity', async () => {
-      const relatedEntityId = 1;
-      const relatedEntity = {
-        id: relatedEntityId,
-        locale: 'fr',
-        localizations: [
-          {
-            id: 2,
-            locale: 'en',
-          },
-        ],
-      };
-      const findOne = jest.fn(() => Promise.resolve(relatedEntity));
-      const model = 'application::country.country';
-      const locale = 'it';
+  describe.each([['singleType'], ['collectionType']])(
+    'getAndValidateRelatedEntity - %s',
+    (kind) => {
+      test("Throw if relatedEntity is provided but doesn't exist", async () => {
+        const findOne = jest.fn(() => Promise.resolve(undefined));
+        const relatedEntityId = 1;
+        const model = 'application::country.country';
+        const locale = 'fr';
+
+        global.strapi = {
+          query: () => ({
+            findOne,
+          }),
+          getModel: () => ({ kind }),
+        };
+
+        try {
+          await getAndValidateRelatedEntity(relatedEntityId, model, locale);
+        } catch (e) {
+          expect(e.message).toBe("The related entity doesn't exist");
+        }
+
+        expect(findOne).toHaveBeenCalledWith(kind === 'singleType' ? {} : { id: relatedEntityId });
+        expect.assertions(2);
+      });
 
-      global.strapi = {
-        query: () => ({
-          findOne,
-        }),
-        getModel: () => ({ kind }),
-      };
+      test('Throw if locale already exists (1/2)', async () => {
+        const relatedEntityId = 1;
+        const relatedEntity = {
+          id: relatedEntityId,
+          locale: 'en',
+          localizations: [],
+        };
+        const findOne = jest.fn(() => Promise.resolve(relatedEntity));
+        const model = 'application::country.country';
+        const locale = 'en';
+
+        global.strapi = {
+          query: () => ({
+            findOne,
+          }),
+          getModel: () => ({ kind }),
+        };
+
+        try {
+          await getAndValidateRelatedEntity(relatedEntityId, model, locale);
+        } catch (e) {
+          expect(e.message).toBe('The entity already exists in this locale');
+        }
+
+        expect(findOne).toHaveBeenCalledWith(kind === 'singleType' ? {} : { id: relatedEntityId });
+        expect.assertions(2);
+      });
 
-      const foundEntity = await getAndValidateRelatedEntity(relatedEntityId, model, locale);
+      test('Throw if locale already exists (2/2)', async () => {
+        const relatedEntityId = 1;
+        const relatedEntity = {
+          id: relatedEntityId,
+          locale: 'fr',
+          localizations: [
+            {
+              id: 2,
+              locale: 'en',
+            },
+          ],
+        };
+        const findOne = jest.fn(() => Promise.resolve(relatedEntity));
+        const model = 'application::country.country';
+        const locale = 'en';
+
+        global.strapi = {
+          query: () => ({
+            findOne,
+          }),
+          getModel: () => ({ kind }),
+        };
+
+        try {
+          await getAndValidateRelatedEntity(relatedEntityId, model, locale);
+        } catch (e) {
+          expect(e.message).toBe('The entity already exists in this locale');
+        }
+
+        expect(findOne).toHaveBeenCalledWith(kind === 'singleType' ? {} : { id: relatedEntityId });
+        expect.assertions(2);
+      });
 
-      expect(foundEntity).toEqual(relatedEntity);
-      expect(findOne).toHaveBeenCalledWith(kind === 'singleType' ? {} : { id: relatedEntityId });
-      expect.assertions(2);
-    });
-  });
+      test('get related entity', async () => {
+        const relatedEntityId = 1;
+        const relatedEntity = {
+          id: relatedEntityId,
+          locale: 'fr',
+          localizations: [
+            {
+              id: 2,
+              locale: 'en',
+            },
+          ],
+        };
+        const findOne = jest.fn(() => Promise.resolve(relatedEntity));
+        const model = 'application::country.country';
+        const locale = 'it';
+
+        global.strapi = {
+          query: () => ({
+            findOne,
+          }),
+          getModel: () => ({ kind }),
+        };
+
+        const foundEntity = await getAndValidateRelatedEntity(relatedEntityId, model, locale);
+
+        expect(foundEntity).toEqual(relatedEntity);
+        expect(findOne).toHaveBeenCalledWith(kind === 'singleType' ? {} : { id: relatedEntityId });
+        expect.assertions(2);
+      });
+    }
+  );
 
   describe('getNewLocalizationsFrom', () => {
     test('Can get localizations', async () => {

package/services/__tests__/entity-service-decorator.test.js

@@ -80,7 +80,7 @@ describe('Entity service decorator', () => {
 
     test('Does not wrap options if model is not localized', async () => {
       const defaultService = {
-        wrapOptions: jest.fn(opts => Promise.resolve(opts)),
+        wrapOptions: jest.fn((opts) => Promise.resolve(opts)),
       };
       const service = decorator(defaultService);
 
@@ -92,7 +92,7 @@ describe('Entity service decorator', () => {
 
     test('does not change non params options', async () => {
       const defaultService = {
-        wrapOptions: jest.fn(opts => Promise.resolve(opts)),
+        wrapOptions: jest.fn((opts) => Promise.resolve(opts)),
       };
       const service = decorator(defaultService);
 
@@ -104,7 +104,7 @@ describe('Entity service decorator', () => {
 
     test('Adds locale param', async () => {
       const defaultService = {
-        wrapOptions: jest.fn(opts => Promise.resolve(opts)),
+        wrapOptions: jest.fn((opts) => Promise.resolve(opts)),
       };
       const service = decorator(defaultService);
 
@@ -133,7 +133,7 @@ describe('Entity service decorator', () => {
       "Doesn't add locale param when the params contain id or id_in - %s",
       async (action, params) => {
         const defaultService = {
-          wrapOptions: jest.fn(opts => Promise.resolve(opts)),
+          wrapOptions: jest.fn((opts) => Promise.resolve(opts)),
         };
         const service = decorator(defaultService);
 
@@ -146,7 +146,7 @@ describe('Entity service decorator', () => {
 
     test('Replaces _locale param', async () => {
       const defaultService = {
-        wrapOptions: jest.fn(opts => Promise.resolve(opts)),
+        wrapOptions: jest.fn((opts) => Promise.resolve(opts)),
       };
       const service = decorator(defaultService);
 

package/services/entity-service-decorator.js

@@ -13,7 +13,7 @@ const paramsContain = (key, params) => {
   return (
     has(key, params) ||
     has(key, params._where) ||
-    (isArray(params._where) && params._where.some(clause => has(key, clause)))
+    (isArray(params._where) && params._where.some((clause) => has(key, clause)))
   );
 };
 
@@ -54,7 +54,7 @@ const wrapParams = async (params = {}, ctx = {}) => {
  * Assigns a valid locale or the default one if not define
  * @param {object} data
  */
-const assignValidLocale = async data => {
+const assignValidLocale = async (data) => {
   const { getValidLocale } = getService('content-types');
 
   try {
@@ -68,7 +68,7 @@ const assignValidLocale = async data => {
  * Decorates the entity service with I18N business logic
  * @param {object} service - entity service
  */
-const decorator = service => ({
+const decorator = (service) => ({
   /**
    * Wraps query options. In particular will add default locale to query params
    * @param {object} opts - Query options object (params, data, files, populate)

package/services/locales.js

@@ -8,13 +8,13 @@ const { getCoreStore } = require('../utils');
 
 const find = (...args) => strapi.query('locale', 'i18n').find(...args);
 
-const findById = id => strapi.query('locale', 'i18n').findOne({ id });
+const findById = (id) => strapi.query('locale', 'i18n').findOne({ id });
 
-const findByCode = code => strapi.query('locale', 'i18n').findOne({ code });
+const findByCode = (code) => strapi.query('locale', 'i18n').findOne({ code });
 
-const count = params => strapi.query('locale', 'i18n').count(params);
+const count = (params) => strapi.query('locale', 'i18n').count(params);
 
-const create = async locale => {
+const create = async (locale) => {
   const result = await strapi.query('locale', 'i18n').create(locale);
 
   getService('metrics').sendDidUpdateI18nLocalesEvent();
@@ -49,7 +49,7 @@ const setDefaultLocale = ({ code }) => getCoreStore().set({ key: 'default_locale
 
 const getDefaultLocale = () => getCoreStore().get({ key: 'default_locale' });
 
-const setIsDefault = async locales => {
+const setIsDefault = async (locales) => {
   if (isNil(locales)) {
     return locales;
   }
@@ -57,7 +57,7 @@ const setIsDefault = async locales => {
   const actualDefault = await getDefaultLocale();
 
   if (Array.isArray(locales)) {
-    return locales.map(locale => ({ ...locale, isDefault: actualDefault === locale.code }));
+    return locales.map((locale) => ({ ...locale, isDefault: actualDefault === locale.code }));
   } else {
     // single locale
     return { ...locales, isDefault: actualDefault === locales.code };

package/services/localizations.js

@@ -8,7 +8,7 @@ const { getService } = require('../utils');
  * Adds the default locale to an object if it isn't defined yet
  * @param {Object} data a data object before being persisted into db
  */
-const assignDefaultLocale = async data => {
+const assignDefaultLocale = async (data) => {
   const { getDefaultLocale } = getService('locales');
 
   if (isNil(data.locale)) {
@@ -26,8 +26,8 @@ const syncLocalizations = async (entry, { model }) => {
   if (Array.isArray(entry.localizations)) {
     const newLocalizations = [entry.id, ...entry.localizations.map(prop('id'))];
 
-    const updateLocalization = id => {
-      const localizations = newLocalizations.filter(localizationId => localizationId !== id);
+    const updateLocalization = (id) => {
+      const localizations = newLocalizations.filter((localizationId) => localizationId !== id);
 
       return strapi.query(model.uid).update({ id }, { localizations });
     };
@@ -52,7 +52,8 @@ const syncNonLocalizedAttributes = async (entry, { model }) => {
       return;
     }
 
-    const updateLocalization = id => strapi.query(model.uid).update({ id }, nonLocalizedAttributes);
+    const updateLocalization = (id) =>
+      strapi.query(model.uid).update({ id }, nonLocalizedAttributes);
 
     await Promise.all(entry.localizations.map(({ id }) => updateLocalization(id)));
   }

package/services/permissions/actions.js

@@ -3,7 +3,7 @@
 const { capitalize, isArray, getOr, prop } = require('lodash/fp');
 const { getService } = require('../../utils');
 
-const actions = ['create', 'read', 'update', 'delete'].map(uid => ({
+const actions = ['create', 'read', 'update', 'delete'].map((uid) => ({
   section: 'settings',
   category: 'Internationalization',
   subCategory: 'Locales',
@@ -44,7 +44,7 @@ const shouldApplyLocalesPropertyToSubject = ({ property, subject }) => {
   return true;
 };
 
-const addAllLocalesToPermissions = async permissions => {
+const addAllLocalesToPermissions = async (permissions) => {
   const { actionProvider } = strapi.admin.services.permission;
   const { find: findAllLocales } = getService('locales');
 
@@ -52,7 +52,7 @@ const addAllLocalesToPermissions = async permissions => {
   const allLocalesCode = allLocales.map(prop('code'));
 
   return Promise.all(
-    permissions.map(async permission => {
+    permissions.map(async (permission) => {
       const { action, subject } = permission;
 
       const appliesToLocalesProperty = await actionProvider.appliesToProperty(
@@ -112,7 +112,7 @@ const updateActionsProperties = () => {
   actionProvider.hooks.willRegister.register(addLocalesPropertyIfNeeded);
 
   // Handle already registered actions
-  actionProvider.values().forEach(action => addLocalesPropertyIfNeeded({ value: action }));
+  actionProvider.values().forEach((action) => addLocalesPropertyIfNeeded({ value: action }));
 };
 
 module.exports = {

package/services/permissions/engine.js

@@ -14,7 +14,7 @@ const { getService } = require('../../utils');
  * Add the has-locale-access condition if the locales property is defined
  * @param {WillRegisterPermissionContext} context
  */
-const willRegisterPermission = context => {
+const willRegisterPermission = (context) => {
   const { permission, condition, user } = context;
   const { subject, properties } = permission;
 

package/services/permissions/sections-builder.js

@@ -23,7 +23,7 @@ const localesPropertyHandler = async ({ action, section }) => {
 
   for (const subject of section.subjects) {
     const applies = await actionProvider.appliesToProperty('locales', action.actionId, subject.uid);
-    const hasLocalesProperty = subject.properties.find(property => property.value === 'locales');
+    const hasLocalesProperty = subject.properties.find((property) => property.value === 'locales');
 
     if (applies && !hasLocalesProperty) {
       subject.properties.push({

package/tests/graphql.test.e2e.js

@@ -35,7 +35,7 @@ describe('Test Graphql API create localization', () => {
     strapi = await createStrapiInstance();
     rq = await createAuthRequest({ strapi });
 
-    graphqlQuery = body => {
+    graphqlQuery = (body) => {
       return rq({
         url: '/graphql',
         method: 'POST',

package/tests/locales.test.e2e.js

@@ -175,8 +175,8 @@ describe('CRUD locales', () => {
       });
 
       expect(res.statusCode).toBe(200);
-      const enLocale = res.body.find(locale => locale.code === 'bas');
-      const enUsLocale = res.body.find(locale => locale.code === 'en-US');
+      const enLocale = res.body.find((locale) => locale.code === 'bas');
+      const enUsLocale = res.body.find((locale) => locale.code === 'en-US');
       expect(enLocale.isDefault).toBe(false);
       expect(enUsLocale.isDefault).toBe(true);
 
@@ -290,8 +290,8 @@ describe('CRUD locales', () => {
       });
 
       expect(res.statusCode).toBe(200);
-      expect(res.body.find(locale => locale.code === data.locales[0].code).isDefault).toBe(false);
-      expect(res.body.find(locale => locale.code === data.locales[1].code).isDefault).toBe(true);
+      expect(res.body.find((locale) => locale.code === data.locales[0].code).isDefault).toBe(false);
+      expect(res.body.find((locale) => locale.code === data.locales[1].code).isDefault).toBe(true);
     });
 
     test('Cannot unselect isDefault', async () => {

package/utils/index.js

@@ -10,7 +10,7 @@ const getCoreStore = () =>
   });
 
 // retrieve a local service
-const getService = name => {
+const getService = (name) => {
   return prop(`i18n.services.${name}`, strapi.plugins);
 };