@akemona-org/strapi-plugin-i18n 3.7.0

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

@@ -0,0 +1,113 @@
+'use strict';
+
+const { getNonLocalizedAttributes } = require('../content-types');
+const ctService = require('../../services/content-types');
+
+describe('i18n - Controller - content-types', () => {
+  describe('getNonLocalizedAttributes', () => {
+    beforeEach(() => {
+      const getModel = () => {};
+      global.strapi = {
+        getModel,
+        plugins: { i18n: { services: { 'content-types': ctService } } },
+        admin: { services: { constants: { READ_ACTION: 'read', CREATE_ACTION: 'create' } } },
+      };
+    });
+
+    test('model not localized', async () => {
+      const badRequest = jest.fn();
+      const ctx = {
+        state: { user: {} },
+        request: {
+          body: {
+            model: 'application::country.country',
+            id: 1,
+            locale: 'fr',
+          },
+        },
+        badRequest,
+      };
+      await getNonLocalizedAttributes(ctx);
+
+      expect(badRequest).toHaveBeenCalledWith('model.not.localized');
+    });
+
+    test('entity not found', async () => {
+      const notFound = jest.fn();
+      const findOne = jest.fn(() => Promise.resolve(undefined));
+      const getModel = jest.fn(() => ({ pluginOptions: { i18n: { localized: true } } }));
+
+      global.strapi.query = () => ({ findOne });
+      global.strapi.getModel = getModel;
+      const ctx = {
+        state: { user: {} },
+        request: {
+          body: {
+            model: 'application::country.country',
+            id: 1,
+            locale: 'fr',
+          },
+        },
+        notFound,
+      };
+      await getNonLocalizedAttributes(ctx);
+
+      expect(notFound).toHaveBeenCalledWith();
+    });
+
+    test('returns nonLocalizedFields', async () => {
+      const model = {
+        pluginOptions: { i18n: { localized: true } },
+        attributes: {
+          name: { type: 'string' },
+          averagePrice: { type: 'integer' },
+          description: { type: 'string', pluginOptions: { i18n: { localized: true } } },
+        },
+      };
+      const entity = {
+        id: 1,
+        name: "Papailhau's Pizza",
+        description: 'Best pizza restaurant of the town',
+        locale: 'en',
+        published_at: '2021-03-30T09:34:54.042Z',
+        localizations: [{ id: 2, locale: 'it', published_at: null }],
+      };
+      const permissions = [
+        { properties: { fields: ['name', 'averagePrice'], locales: ['it'] } },
+        { properties: { fields: ['name', 'description'], locales: ['fr'] } },
+        { properties: { fields: ['name'], locales: ['fr'] } },
+      ];
+
+      const findOne = jest.fn(() => Promise.resolve(entity));
+      const find = jest.fn(() => Promise.resolve(permissions));
+      const getModel = jest.fn(() => model);
+
+      global.strapi.query = () => ({ findOne });
+      global.strapi.getModel = getModel;
+      global.strapi.admin.services.permission = { find };
+      const ctx = {
+        state: { user: { roles: [{ id: 1 }, { id: 2 }] } },
+        request: {
+          body: {
+            model: 'application::country.country',
+            id: 1,
+            locale: 'fr',
+          },
+        },
+      };
+      await getNonLocalizedAttributes(ctx);
+      expect(find).toHaveBeenCalledWith({
+        action_in: ['read', 'create'],
+        subject: 'application::country.country',
+        role_in: [1, 2],
+      });
+      expect(ctx.body).toEqual({
+        nonLocalizedFields: { name: "Papailhau's Pizza" },
+        localizations: [
+          { id: 2, locale: 'it', published_at: null },
+          { id: 1, locale: 'en', published_at: '2021-03-30T09:34:54.042Z' },
+        ],
+      });
+    });
+  });
+});

package/controllers/__tests__/iso-locales.test.js

@@ -0,0 +1,26 @@
+'use strict';
+
+const { listIsoLocales } = require('../iso-locales');
+
+describe('ISO locales', () => {
+  test('listIsoLocales', () => {
+    const isoLocales = [{ code: 'af', name: 'Afrikaans (af)' }];
+    const getIsoLocales = jest.fn(() => isoLocales);
+    global.strapi = {
+      plugins: {
+        i18n: {
+          services: {
+            'iso-locales': {
+              getIsoLocales,
+            },
+          },
+        },
+      },
+    };
+
+    const ctx = {};
+    listIsoLocales(ctx);
+
+    expect(ctx.body).toMatchObject(isoLocales);
+  });
+});

package/controllers/__tests__/locales.test.js

@@ -0,0 +1,308 @@
+'use strict';
+
+const { listLocales, createLocale, updateLocale, deleteLocale } = require('../locales');
+const localeModel = require('../../models/Locale.settings');
+
+describe('Locales', () => {
+  describe('listLocales', () => {
+    test('can get locales', async () => {
+      const locales = [{ code: 'af', name: 'Afrikaans (af)' }];
+      const expectedLocales = [{ code: 'af', name: 'Afrikaans (af)', isDefault: true }];
+      const setIsDefault = jest.fn(() => expectedLocales);
+      const find = jest.fn(() => locales);
+      const getModel = jest.fn(() => localeModel);
+      global.strapi = {
+        getModel,
+        plugins: {
+          i18n: {
+            services: {
+              locales: {
+                find,
+                setIsDefault,
+              },
+            },
+          },
+        },
+      };
+
+      const ctx = {};
+      await listLocales(ctx);
+
+      expect(setIsDefault).toHaveBeenCalledWith(locales);
+      expect(find).toHaveBeenCalledWith();
+      expect(ctx.body).toMatchObject(expectedLocales);
+    });
+  });
+
+  describe('createLocale', () => {
+    test('can create a locale (isDefault: true)', async () => {
+      const locale = { code: 'af', name: 'Afrikaans (af)' };
+      const expectedLocales = { code: 'af', name: 'Afrikaans (af)', isDefault: true };
+      const getDefaultLocale = jest.fn(() => Promise.resolve('af'));
+      const setDefaultLocale = jest.fn(() => Promise.resolve());
+
+      const setIsDefault = jest.fn(() => expectedLocales);
+      const findByCode = jest.fn(() => undefined);
+      const create = jest.fn(() => Promise.resolve(locale));
+      const getModel = jest.fn(() => localeModel);
+      global.strapi = {
+        getModel,
+        plugins: {
+          i18n: {
+            services: {
+              locales: {
+                findByCode,
+                setIsDefault,
+                getDefaultLocale,
+                setDefaultLocale,
+                create,
+              },
+            },
+          },
+        },
+      };
+
+      const ctx = { request: { body: { ...locale, isDefault: true } }, state: { user: { id: 1 } } };
+      await createLocale(ctx);
+
+      expect(setIsDefault).toHaveBeenCalledWith(locale);
+      expect(setDefaultLocale).toHaveBeenCalledWith(locale);
+      expect(findByCode).toHaveBeenCalledWith('af');
+      expect(create).toHaveBeenCalledWith({ created_by: 1, updated_by: 1, ...locale });
+      expect(ctx.body).toMatchObject(expectedLocales);
+    });
+
+    test('can create a locale (isDefault: false)', async () => {
+      const locale = { code: 'af', name: 'Afrikaans (af)' };
+      const expectedLocale = { code: 'af', name: 'Afrikaans (af)', isDefault: false };
+      const getDefaultLocale = jest.fn(() => Promise.resolve('en'));
+
+      const setIsDefault = jest.fn(() => expectedLocale);
+      const findByCode = jest.fn(() => undefined);
+      const create = jest.fn(() => Promise.resolve(locale));
+      const getModel = jest.fn(() => localeModel);
+      global.strapi = {
+        getModel,
+        plugins: {
+          i18n: {
+            services: {
+              locales: {
+                findByCode,
+                setIsDefault,
+                getDefaultLocale,
+                create,
+              },
+            },
+          },
+        },
+      };
+
+      const ctx = {
+        request: { body: { ...locale, isDefault: false } },
+        state: { user: { id: 1 } },
+      };
+      await createLocale(ctx);
+
+      expect(setIsDefault).toHaveBeenCalledWith(locale);
+      expect(findByCode).toHaveBeenCalledWith('af');
+      expect(create).toHaveBeenCalledWith({ created_by: 1, updated_by: 1, ...locale });
+      expect(ctx.body).toMatchObject(expectedLocale);
+    });
+
+    test('cannot create a locale that already exists', async () => {
+      const locale = { code: 'af', name: 'Afrikaans (af)' };
+      const expectedLocale = { code: 'af', name: 'Afrikaans (af)', isDefault: false };
+      const getDefaultLocale = jest.fn(() => Promise.resolve('en'));
+
+      const setIsDefault = jest.fn(() => expectedLocale);
+      const findByCode = jest.fn(() => ({ name: 'other locale', code: 'af' }));
+      const create = jest.fn(() => Promise.resolve(locale));
+      const badRequest = jest.fn();
+      const getModel = jest.fn(() => localeModel);
+      global.strapi = {
+        getModel,
+        plugins: {
+          i18n: {
+            services: {
+              locales: {
+                findByCode,
+                setIsDefault,
+                getDefaultLocale,
+                create,
+              },
+            },
+          },
+        },
+      };
+
+      const ctx = {
+        badRequest,
+        request: { body: { ...locale, isDefault: false } },
+        state: { user: { id: 1 } },
+      };
+      await createLocale(ctx);
+
+      expect(findByCode).toHaveBeenCalledWith('af');
+      expect(badRequest).toHaveBeenCalledWith('This locale already exists');
+      expect(create).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('updateLocale', () => {
+    test('can update a locale', async () => {
+      const updatedLocale = { name: 'Afrikaans', code: 'af' };
+      const existingLocale = { name: 'Afrikaans (af)', code: 'af' };
+      const updates = { name: 'Afrikaans' };
+      const expectedLocales = { code: 'af', name: 'Afrikaans', isDefault: true };
+      const setDefaultLocale = jest.fn(() => Promise.resolve());
+
+      const setIsDefault = jest.fn(() => expectedLocales);
+      const findById = jest.fn(() => existingLocale);
+      const update = jest.fn(() => Promise.resolve(updatedLocale));
+      const getModel = jest.fn(() => localeModel);
+      global.strapi = {
+        getModel,
+        plugins: {
+          i18n: {
+            services: {
+              locales: {
+                findById,
+                setIsDefault,
+                setDefaultLocale,
+                update,
+              },
+            },
+          },
+        },
+      };
+
+      const ctx = {
+        params: { id: 1 },
+        request: { body: { ...updates, isDefault: true } },
+        state: { user: { id: 1 } },
+      };
+      await updateLocale(ctx);
+
+      expect(setIsDefault).toHaveBeenCalledWith(updatedLocale);
+      expect(setDefaultLocale).toHaveBeenCalledWith(updatedLocale);
+      expect(findById).toHaveBeenCalledWith(1);
+      expect(update).toHaveBeenCalledWith({ id: 1 }, { updated_by: 1, ...updates });
+      expect(ctx.body).toMatchObject(expectedLocales);
+    });
+
+    test('cannot update the code of a locale', async () => {
+      const updatedLocale = { name: 'Afrikaans', code: 'af' };
+      const existingLocale = { name: 'Afrikaans (af)', code: 'af' };
+      const updates = { name: 'Afrikaans', code: 'fr' };
+      const expectedLocales = { code: 'af', name: 'Afrikaans', isDefault: true };
+      const setDefaultLocale = jest.fn(() => Promise.resolve());
+
+      const setIsDefault = jest.fn(() => expectedLocales);
+      const findById = jest.fn(() => existingLocale);
+      const update = jest.fn(() => Promise.resolve(updatedLocale));
+      const getModel = jest.fn(() => localeModel);
+      const badRequest = jest.fn();
+      global.strapi = {
+        getModel,
+        plugins: {
+          i18n: {
+            services: {
+              locales: {
+                findById,
+                setIsDefault,
+                setDefaultLocale,
+                update,
+              },
+            },
+          },
+        },
+      };
+
+      const ctx = {
+        badRequest,
+        params: { id: 1 },
+        request: { body: { ...updates, isDefault: true } },
+        state: { user: { id: 1 } },
+      };
+
+      await updateLocale(ctx);
+
+      expect(badRequest).toHaveBeenCalled();
+      expect(findById).not.toHaveBeenCalled();
+      expect(update).not.toHaveBeenCalled();
+      expect(setIsDefault).not.toHaveBeenCalled();
+      expect(setDefaultLocale).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('deleteLocale', () => {
+    test('can delete a locale', async () => {
+      const locale = { code: 'af', name: 'Afrikaans (af)' };
+      const expectedLocales = { code: 'af', name: 'Afrikaans (af)', isDefault: false };
+      const getDefaultLocale = jest.fn(() => Promise.resolve('en'));
+
+      const setIsDefault = jest.fn(() => expectedLocales);
+      const findById = jest.fn(() => locale);
+      const deleteFn = jest.fn();
+      const getModel = jest.fn(() => localeModel);
+      global.strapi = {
+        getModel,
+        plugins: {
+          i18n: {
+            services: {
+              locales: {
+                findById,
+                setIsDefault,
+                getDefaultLocale,
+                delete: deleteFn,
+              },
+            },
+          },
+        },
+      };
+
+      const ctx = { params: { id: 1 } };
+      await deleteLocale(ctx);
+
+      expect(setIsDefault).toHaveBeenCalledWith(locale);
+      expect(findById).toHaveBeenCalledWith(1);
+      expect(deleteFn).toHaveBeenCalledWith({ id: 1 });
+      expect(ctx.body).toMatchObject(expectedLocales);
+    });
+
+    test('cannot delete the default locale', async () => {
+      const locale = { code: 'af', name: 'Afrikaans (af)' };
+      const expectedLocales = { code: 'af', name: 'Afrikaans (af)', isDefault: false };
+      const getDefaultLocale = jest.fn(() => Promise.resolve('af'));
+
+      const setIsDefault = jest.fn(() => Promise.resolve(expectedLocales));
+      const findById = jest.fn(() => Promise.resolve(locale));
+      const badRequest = jest.fn();
+      const deleteFn = jest.fn();
+      const getModel = jest.fn(() => localeModel);
+      global.strapi = {
+        getModel,
+        plugins: {
+          i18n: {
+            services: {
+              locales: {
+                findById,
+                getDefaultLocale,
+                delete: deleteFn,
+              },
+            },
+          },
+        },
+      };
+
+      const ctx = { params: { id: 1 }, badRequest };
+      await deleteLocale(ctx);
+
+      expect(badRequest).toHaveBeenCalledWith('Cannot delete the default locale');
+
+      expect(findById).toHaveBeenCalledWith(1);
+      expect(setIsDefault).not.toHaveBeenCalled();
+      expect(deleteFn).not.toHaveBeenCalled();
+    });
+  });
+});

package/controllers/content-types.js

@@ -0,0 +1,64 @@
+'use strict';
+
+const { pick, uniq, prop, getOr, flatten, pipe, map } = require('lodash/fp');
+const { contentTypes: contentTypesUtils } = require('@akemona-org/strapi-utils');
+const { getService } = require('../utils');
+const { validateGetNonLocalizedAttributesInput } = require('../validation/content-types');
+
+const { PUBLISHED_AT_ATTRIBUTE } = contentTypesUtils.constants;
+
+const getLocalesProperty = getOr([], 'properties.locales');
+const getFieldsProperty = prop('properties.fields');
+
+const getFirstLevelPath = map((path) => path.split('.')[0]);
+
+module.exports = {
+  async getNonLocalizedAttributes(ctx) {
+    const { user } = ctx.state;
+    const { model, id, locale } = ctx.request.body;
+
+    try {
+      await validateGetNonLocalizedAttributesInput({ model, id, locale });
+    } catch (err) {
+      return ctx.badRequest('ValidationError', err);
+    }
+
+    const modelDef = strapi.getModel(model);
+    const { copyNonLocalizedAttributes, isLocalizedContentType } = getService('content-types');
+    const { READ_ACTION, CREATE_ACTION } = strapi.admin.services.constants;
+
+    if (!isLocalizedContentType(modelDef)) {
+      return ctx.badRequest('model.not.localized');
+    }
+
+    let params = modelDef.kind === 'singleType' ? {} : { id };
+
+    const entity = await strapi.query(model).findOne(params);
+
+    if (!entity) {
+      return ctx.notFound();
+    }
+
+    const permissions = await strapi.admin.services.permission.find({
+      action_in: [READ_ACTION, CREATE_ACTION],
+      subject: model,
+      role_in: user.roles.map(prop('id')),
+    });
+
+    const localePermissions = permissions
+      .filter((perm) => getLocalesProperty(perm).includes(locale))
+      .map(getFieldsProperty);
+
+    const permittedFields = pipe(flatten, getFirstLevelPath, uniq)(localePermissions);
+
+    const nonLocalizedFields = copyNonLocalizedAttributes(modelDef, entity);
+    const sanitizedNonLocalizedFields = pick(permittedFields, nonLocalizedFields);
+
+    ctx.body = {
+      nonLocalizedFields: sanitizedNonLocalizedFields,
+      localizations: entity.localizations.concat(
+        pick(['id', 'locale', PUBLISHED_AT_ATTRIBUTE], entity)
+      ),
+    };
+  },
+};

package/controllers/iso-locales.js

@@ -0,0 +1,11 @@
+'use strict';
+
+const { getService } = require('../utils');
+
+module.exports = {
+  listIsoLocales(ctx) {
+    const isoLocalesService = getService('iso-locales');
+
+    ctx.body = isoLocalesService.getIsoLocales();
+  },
+};

package/controllers/locales.js

@@ -0,0 +1,104 @@
+'use strict';
+
+const { setCreatorFields, sanitizeEntity } = require('@akemona-org/strapi-utils');
+const { pick } = require('lodash/fp');
+const { getService } = require('../utils');
+const { validateCreateLocaleInput, validateUpdateLocaleInput } = require('../validation/locales');
+const { formatLocale } = require('../domain/locale');
+
+const sanitizeLocale = (locale) => {
+  const model = strapi.getModel('locale', 'i18n');
+
+  return sanitizeEntity(locale, { model });
+};
+
+module.exports = {
+  async listLocales(ctx) {
+    const localesService = getService('locales');
+
+    const locales = await localesService.find();
+
+    ctx.body = await localesService.setIsDefault(sanitizeLocale(locales));
+  },
+
+  async createLocale(ctx) {
+    const { user } = ctx.state;
+    const { body } = ctx.request;
+    let { isDefault, ...localeToCreate } = body;
+
+    try {
+      await validateCreateLocaleInput(body);
+    } catch (err) {
+      return ctx.badRequest('ValidationError', err);
+    }
+
+    const localesService = getService('locales');
+
+    const existingLocale = await localesService.findByCode(body.code);
+    if (existingLocale) {
+      return ctx.badRequest('This locale already exists');
+    }
+
+    localeToCreate = formatLocale(localeToCreate);
+    localeToCreate = setCreatorFields({ user })(localeToCreate);
+
+    const locale = await localesService.create(localeToCreate);
+
+    if (isDefault) {
+      await localesService.setDefaultLocale(locale);
+    }
+
+    ctx.body = await localesService.setIsDefault(sanitizeLocale(locale));
+  },
+
+  async updateLocale(ctx) {
+    const { user } = ctx.state;
+    const { id } = ctx.params;
+    const { body } = ctx.request;
+    let { isDefault, ...updates } = body;
+
+    try {
+      await validateUpdateLocaleInput(body);
+    } catch (err) {
+      return ctx.badRequest('ValidationError', err);
+    }
+
+    const localesService = getService('locales');
+
+    const existingLocale = await localesService.findById(id);
+    if (!existingLocale) {
+      return ctx.notFound('locale.notFound');
+    }
+
+    const allowedParams = ['name'];
+    const cleanUpdates = setCreatorFields({ user, isEdition: true })(pick(allowedParams, updates));
+
+    const updatedLocale = await localesService.update({ id }, cleanUpdates);
+
+    if (isDefault) {
+      await localesService.setDefaultLocale(updatedLocale);
+    }
+
+    ctx.body = await localesService.setIsDefault(sanitizeLocale(updatedLocale));
+  },
+
+  async deleteLocale(ctx) {
+    const { id } = ctx.params;
+
+    const localesService = getService('locales');
+
+    const existingLocale = await localesService.findById(id);
+    if (!existingLocale) {
+      return ctx.notFound('locale.notFound');
+    }
+
+    const defaultLocaleCode = await localesService.getDefaultLocale();
+    if (existingLocale.code === defaultLocaleCode) {
+      return ctx.badRequest('Cannot delete the default locale');
+    }
+
+    await localesService.delete({ id });
+
+    ctx.body = await localesService.setIsDefault(sanitizeLocale(existingLocale));
+  },
+};

package/domain/locale.js

@@ -0,0 +1,10 @@
+'use strict';
+
+const formatLocale = locale => {
+  return {
+    ...locale,
+    name: locale.name || null,
+  };
+};
+
+module.exports = { formatLocale };

package/middlewares/i18n/defaults.json

@@ -0,0 +1,5 @@
+{
+  "i18n": {
+    "enabled": true
+  }
+}

package/middlewares/i18n/index.js

@@ -0,0 +1,28 @@
+'use strict';
+
+const { getOr, get, isMatch } = require('lodash/fp');
+const _ = require('lodash');
+
+module.exports = strapi => {
+  return {
+    beforeInitialize() {
+      strapi.config.middleware.load.before.unshift('i18n');
+    },
+
+    initialize() {
+      const routes = get('plugins.content-manager.config.routes', strapi);
+      const routesToAddPolicyTo = routes.filter(
+        route =>
+          isMatch({ method: 'POST', path: '/collection-types/:model' }, route) ||
+          isMatch({ method: 'PUT', path: '/single-types/:model' }, route)
+      );
+
+      routesToAddPolicyTo.forEach(route => {
+        const policies = getOr([], 'config.policies', route).concat(
+          'plugins::i18n.validateLocaleCreation'
+        );
+        _.set(route, 'config.policies', policies);
+      });
+    },
+  };
+};