@akemona-org/strapi-plugin-i18n 3.7.0

package/admin/src/utils/tests/mutateCTBContentTypeSchema.test.js

@@ -0,0 +1,205 @@
+import mutateSchema, {
+  addLocalisationToFields,
+  disableAttributesLocalisation,
+} from '../mutateCTBContentTypeSchema';
+
+describe('i18n | utils ', () => {
+  describe('mutateCTBContentTypeSchema', () => {
+    it('should forward the data the pluginOptions.i18n.localized key does not exist in the content type', () => {
+      const data = { pluginOptions: { test: true } };
+
+      expect(mutateSchema(data)).toEqual(data);
+    });
+
+    it('should remove the pluginOptions.i18n key from the content type schema', () => {
+      const ctSchema = {
+        pluginOptions: {
+          pluginA: { foo: 'bar' },
+          i18n: { localized: false },
+          pluginB: { foo: 'bar' },
+        },
+        kind: 'test',
+        attributes: {
+          one: {
+            type: 'string',
+            pluginOptions: {
+              i18n: { localized: true },
+            },
+            required: true,
+          },
+          two: {
+            type: 'number',
+            pluginOptions: {
+              pluginA: { test: true },
+              i18n: { localized: true },
+            },
+          },
+        },
+      };
+
+      const expected = {
+        pluginOptions: {
+          pluginA: { foo: 'bar' },
+          pluginB: { foo: 'bar' },
+        },
+        kind: 'test',
+        attributes: {
+          one: {
+            type: 'string',
+            pluginOptions: {},
+            required: true,
+          },
+          two: {
+            type: 'number',
+            pluginOptions: {
+              pluginA: { test: true },
+            },
+          },
+        },
+      };
+
+      expect(mutateSchema(ctSchema, {})).toEqual(expected);
+    });
+
+    it('should return the data if the initial schema already has i18n enabled', () => {
+      const ctSchema = {
+        pluginOptions: {
+          pluginA: { foo: 'bar' },
+          i18n: { localized: true },
+          pluginB: { foo: 'bar' },
+        },
+        kind: 'test',
+        attributes: {
+          one: {
+            type: 'string',
+            pluginOptions: {
+              i18n: { localized: true },
+            },
+            required: true,
+          },
+          two: {
+            type: 'number',
+            pluginOptions: {
+              pluginA: { test: true },
+              i18n: { localized: true },
+            },
+          },
+        },
+      };
+
+      expect(
+        mutateSchema(ctSchema, {
+          schema: {
+            pluginOptions: {
+              pluginA: { foo: 'bar' },
+              i18n: { localized: true },
+              pluginB: { foo: 'bar' },
+            },
+          },
+        })
+      ).toEqual(ctSchema);
+    });
+
+    it('should set the pluginOptions.i18n.localized to true an all attributes', () => {
+      const nextSchema = {
+        pluginOptions: { pluginA: { ok: true }, i18n: { localized: true } },
+        attributes: {
+          cover: { type: 'media', pluginOptions: { pluginA: { ok: true } } },
+          name: {
+            type: 'text',
+            pluginOptions: { pluginA: { ok: true }, i18n: { localized: false } },
+          },
+          price: {
+            type: 'text',
+          },
+        },
+      };
+      const expected = {
+        pluginOptions: { pluginA: { ok: true }, i18n: { localized: true } },
+        attributes: {
+          cover: {
+            type: 'media',
+            pluginOptions: { pluginA: { ok: true }, i18n: { localized: true } },
+          },
+          name: {
+            type: 'text',
+            pluginOptions: { pluginA: { ok: true }, i18n: { localized: true } },
+          },
+          price: {
+            type: 'text',
+            pluginOptions: { i18n: { localized: true } },
+          },
+        },
+      };
+
+      expect(mutateSchema(nextSchema, {})).toEqual(expected);
+    });
+  });
+
+  describe('i18n addLocalisationToFields', () => {
+    it('should forward the data if the attribute type is not correct', () => {
+      const attributes = {
+        foo: { type: 'relation' },
+        bar: { type: 'custom' },
+      };
+
+      expect(addLocalisationToFields(attributes)).toEqual(attributes);
+    });
+
+    it('should keep the pluginOptions for each attribute and enable the i18n.localized value', () => {
+      const attributes = {
+        foo: { type: 'text', pluginOptions: { pluginA: { ok: true } }, required: true },
+        bar: { type: 'text', pluginOptions: { i18n: { localized: false } } },
+      };
+
+      const expected = {
+        foo: {
+          type: 'text',
+          pluginOptions: { pluginA: { ok: true }, i18n: { localized: true } },
+          required: true,
+        },
+        bar: { type: 'text', pluginOptions: { i18n: { localized: true } } },
+      };
+
+      expect(addLocalisationToFields(attributes)).toEqual(expected);
+    });
+
+    it('should enable the pluginOptions.i18n.localized value for each attribute', () => {
+      const attributes = {
+        foo: { type: 'text', required: true },
+        bar: { type: 'text' },
+      };
+
+      const expected = {
+        foo: {
+          type: 'text',
+          pluginOptions: { i18n: { localized: true } },
+          required: true,
+        },
+        bar: { type: 'text', pluginOptions: { i18n: { localized: true } } },
+      };
+
+      expect(addLocalisationToFields(attributes)).toEqual(expected);
+    });
+  });
+
+  describe('disableAttributesLocalisation', () => {
+    it('should remove the pluginOptions.i18n for all attributes', () => {
+      const attributes = {
+        foo: {
+          type: 'text',
+          pluginOptions: { pluginA: { ok: true }, i18n: { localized: true } },
+          required: true,
+        },
+        bar: { type: 'text', pluginOptions: { i18n: { localized: true } } },
+      };
+
+      const expected = {
+        foo: { type: 'text', required: true, pluginOptions: { pluginA: { ok: true } } },
+        bar: { type: 'text', pluginOptions: {} },
+      };
+
+      expect(disableAttributesLocalisation(attributes)).toEqual(expected);
+    });
+  });
+});

package/config/functions/bootstrap.js

@@ -0,0 +1,57 @@
+'use strict';
+
+const { getService } = require('../../utils');
+
+module.exports = async () => {
+  const { sendDidInitializeEvent } = getService('metrics');
+  const { decorator } = getService('entity-service-decorator');
+  const { initDefaultLocale } = getService('locales');
+  const { sectionsBuilder, actions, engine } = getService('permissions');
+
+  // Entity Service
+  strapi.entityService.decorate(decorator);
+
+  // Data
+  await initDefaultLocale();
+
+  // Sections Builder
+  sectionsBuilder.registerLocalesPropertyHandler();
+
+  // Actions
+  await actions.registerI18nActions();
+  actions.registerI18nActionsHooks();
+  actions.updateActionsProperties();
+
+  // Engine/Permissions
+  engine.registerI18nPermissionsHandlers();
+
+  // Hooks & Models
+  registerModelsHooks();
+
+  sendDidInitializeEvent();
+};
+
+const registerModelsHooks = () => {
+  Object.values(strapi.models)
+    .filter(model => getService('content-types').isLocalizedContentType(model))
+    .forEach(model => {
+      strapi.db.lifecycles.register({
+        model: model.uid,
+        async beforeCreate(data) {
+          await getService('localizations').assignDefaultLocale(data);
+        },
+      });
+    });
+
+  strapi.db.lifecycles.register({
+    model: 'plugins::i18n.locale',
+
+    async afterCreate() {
+      await getService('permissions').actions.syncSuperAdminPermissionsWithLocales();
+    },
+
+    async afterDelete() {
+      await getService('permissions').actions.syncSuperAdminPermissionsWithLocales();
+    },
+  });
+};

package/config/functions/migrations/__tests__/content-type.test.js

@@ -0,0 +1,255 @@
+'use strict';
+
+const { after } = require('../content-type/enable');
+const { before } = require('../content-type/disable');
+const ctService = require('../../../../services/content-types');
+
+describe('i18n - Migration - enable/disable localization on a CT', () => {
+  beforeAll(() => {
+    global.strapi = {
+      plugins: { i18n: { services: { 'content-types': ctService } } },
+    };
+  });
+
+  describe('enable localization on a CT', () => {
+    describe('Should not migrate', () => {
+      test('non i18n => non i18n', async () => {
+        const previousDefinition = {};
+        const definition = {};
+
+        await after({ definition, previousDefinition });
+      });
+
+      test('i18n => non i18n', async () => {
+        const previousDefinition = { pluginOptions: { i18n: { localized: true } } };
+        const definition = {};
+
+        await after({ definition, previousDefinition });
+      });
+
+      test('i18n => i18n', async () => {
+        const previousDefinition = { pluginOptions: { i18n: { localized: true } } };
+        const definition = { pluginOptions: { i18n: { localized: true } } };
+
+        await after({ definition, previousDefinition });
+      });
+    });
+    describe('Should migrate', () => {
+      describe('bookshelf', () => {
+        test('non i18n => i18n - default locale in core_store', async () => {
+          const model = { orm: 'bookshelf' };
+          const previousDefinition = {};
+          const definition = { pluginOptions: { i18n: { localized: true } } };
+          const defaultLocaleRows = [{ value: '"fr"' }];
+          const where = jest.fn().mockReturnValueOnce(Promise.resolve(defaultLocaleRows));
+
+          const knex = { where };
+          knex.select = () => knex;
+          knex.from = () => knex;
+          knex.update = jest.fn(() => knex);
+
+          const ORM = { knex };
+
+          await after({ model, definition, previousDefinition, ORM });
+
+          expect(knex.update).toHaveBeenCalledWith({ locale: 'fr' });
+        });
+
+        test('non i18n => i18n - default locale not in core_store', async () => {
+          const model = { orm: 'bookshelf' };
+          const previousDefinition = {};
+          const definition = { pluginOptions: { i18n: { localized: true } } };
+          const defaultLocaleRows = [];
+          const where = jest.fn().mockReturnValueOnce(Promise.resolve(defaultLocaleRows));
+
+          const knex = { where };
+          knex.select = () => knex;
+          knex.from = () => knex;
+          knex.update = jest.fn(() => knex);
+
+          const ORM = { knex };
+
+          await after({ model, definition, previousDefinition, ORM });
+
+          expect(knex.update).toHaveBeenCalledWith({ locale: 'en' });
+        });
+      });
+      describe('mongoose', () => {
+        test('non i18n => i18n - default locale in core_store', async () => {
+          const previousDefinition = {};
+          const definition = { pluginOptions: { i18n: { localized: true } } };
+          const defaultLocaleRows = [{ value: '"fr"' }];
+          const find = jest.fn(() => Promise.resolve(defaultLocaleRows));
+          const updateMany = jest.fn();
+          const model = { orm: 'mongoose', updateMany };
+          global.strapi.models = { core_store: { find } };
+
+          await after({ model, definition, previousDefinition });
+
+          expect(updateMany).toHaveBeenCalledWith(
+            { $or: [{ locale: { $exists: false } }, { locale: null }] },
+            { locale: 'fr' }
+          );
+        });
+
+        test('non i18n => i18n - default locale not in core_store', async () => {
+          const previousDefinition = {};
+          const definition = { pluginOptions: { i18n: { localized: true } } };
+          const defaultLocaleRows = [];
+          const find = jest.fn(() => Promise.resolve(defaultLocaleRows));
+          const updateMany = jest.fn();
+          const model = { orm: 'mongoose', updateMany };
+          global.strapi.models = { core_store: { find } };
+
+          await after({ model, definition, previousDefinition });
+
+          expect(updateMany).toHaveBeenCalledWith(
+            { $or: [{ locale: { $exists: false } }, { locale: null }] },
+            { locale: 'en' }
+          );
+        });
+      });
+    });
+  });
+
+  describe('disable localization on a CT', () => {
+    describe('Should not migrate', () => {
+      test('non i18n => non i18n', async () => {
+        const previousDefinition = {};
+        const definition = {};
+
+        await before({ definition, previousDefinition });
+      });
+
+      test('non i18n => i18n', async () => {
+        const previousDefinition = {};
+        const definition = { pluginOptions: { i18n: { localized: true } } };
+
+        await before({ definition, previousDefinition });
+      });
+
+      test('i18n => i18n', async () => {
+        const previousDefinition = { pluginOptions: { i18n: { localized: true } } };
+        const definition = { pluginOptions: { i18n: { localized: true } } };
+
+        await before({ definition, previousDefinition });
+      });
+    });
+    describe('Should migrate', () => {
+      describe('bookshelf', () => {
+        test('i18n => non i18n - pg', async () => {
+          const previousDefinition = {
+            pluginOptions: { i18n: { localized: true } },
+            collectionName: 'countries',
+          };
+          const definition = { client: 'pg' };
+          const defaultLocaleRows = [{ value: '"fr"' }];
+          const deleteRelations = jest.fn();
+          const dropTableIfExists = jest.fn();
+          const table = jest.fn();
+          const model = { orm: 'bookshelf', deleteRelations };
+          const where = jest.fn(() => Promise.resolve(defaultLocaleRows));
+          const trx = {
+            limit: jest.fn(),
+            commit: jest.fn(),
+          };
+          trx.select = jest.fn(() => trx);
+          trx.del = jest.fn(() => trx);
+          trx.from = jest.fn(() => trx);
+          trx.whereNot = jest.fn().mockReturnValueOnce(trx);
+          trx.orderBy = jest.fn(() => trx);
+          trx.offset = jest.fn(() => trx);
+          trx.limit = jest.fn(() => Promise.resolve([{ id: 1 }, { id: 2 }]));
+          const transaction = jest.fn(() => Promise.resolve(trx));
+          const knex = { where, transaction, schema: { dropTableIfExists, table } };
+          knex.select = jest.fn(() => knex);
+          knex.from = jest.fn(() => knex);
+          const ORM = { knex };
+
+          await before({ model, definition, previousDefinition, ORM });
+
+          expect(deleteRelations).toHaveBeenCalledTimes(2);
+          expect(deleteRelations).toHaveBeenNthCalledWith(1, 1, { transacting: trx });
+          expect(deleteRelations).toHaveBeenNthCalledWith(2, 2, { transacting: trx });
+          expect(trx.del).toHaveBeenCalled();
+          expect(trx.whereNot).toHaveBeenNthCalledWith(2, 'locale', 'fr');
+          expect(transaction).toHaveBeenCalled();
+          expect(trx.commit).toHaveBeenCalled();
+          expect(table).toHaveBeenCalled();
+          expect(dropTableIfExists).toHaveBeenCalledWith('countries__localizations');
+        });
+        test('i18n => non i18n - sqlite', async () => {
+          const previousDefinition = {
+            pluginOptions: { i18n: { localized: true } },
+            collectionName: 'countries',
+          };
+          const definition = { client: 'sqlite3' };
+          const defaultLocaleRows = [{ value: '"fr"' }];
+          const deleteRelations = jest.fn();
+          const dropTableIfExists = jest.fn();
+          const table = jest.fn();
+          const model = { orm: 'bookshelf', deleteRelations };
+          const where = jest.fn(() => Promise.resolve(defaultLocaleRows));
+          const trx = {
+            limit: jest.fn(),
+            commit: jest.fn(),
+          };
+          trx.select = jest.fn(() => trx);
+          trx.del = jest.fn(() => trx);
+          trx.from = jest.fn(() => trx);
+          trx.whereNot = jest.fn().mockReturnValueOnce(trx);
+          trx.orderBy = jest.fn(() => trx);
+          trx.offset = jest.fn(() => trx);
+          trx.limit = jest.fn(() => Promise.resolve([{ id: 1 }, { id: 2 }]));
+          const transaction = jest.fn(() => Promise.resolve(trx));
+          const knex = { where, transaction, schema: { dropTableIfExists, table } };
+          knex.select = jest.fn(() => knex);
+          knex.from = jest.fn(() => knex);
+          const ORM = { knex };
+
+          const context = {};
+          await before({ model, definition, previousDefinition, ORM }, context);
+
+          expect(deleteRelations).toHaveBeenCalledTimes(2);
+          expect(deleteRelations).toHaveBeenNthCalledWith(1, 1, { transacting: trx });
+          expect(deleteRelations).toHaveBeenNthCalledWith(2, 2, { transacting: trx });
+          expect(trx.del).toHaveBeenCalled();
+          expect(trx.whereNot).toHaveBeenNthCalledWith(2, 'locale', 'fr');
+          expect(transaction).toHaveBeenCalled();
+          expect(trx.commit).toHaveBeenCalled();
+          expect(table).not.toHaveBeenCalled();
+          expect(context).toEqual({ recreateSqliteTable: true });
+          expect(dropTableIfExists).toHaveBeenCalledWith('countries__localizations');
+        });
+      });
+      describe('mongoose', () => {
+        test('i18n => non i18n', async () => {
+          const previousDefinition = { pluginOptions: { i18n: { localized: true } } };
+          const definition = {};
+          const defaultLocaleRows = [{ value: '"fr"' }];
+          const coreStoreFind = jest.fn(() => Promise.resolve(defaultLocaleRows));
+          const updateMany = jest.fn();
+          const deleteMany = jest.fn();
+          const deleteRelations = jest.fn();
+          const model = { orm: 'mongoose', updateMany, deleteMany, deleteRelations };
+          model.sort = jest.fn(() => model);
+          model.find = jest.fn(() => model);
+          model.limit = jest.fn(() => Promise.resolve([{ id: 1 }, { id: 2 }]));
+          global.strapi.models = { core_store: { find: coreStoreFind } };
+
+          await before({ model, definition, previousDefinition });
+
+          expect(deleteRelations).toHaveBeenCalledTimes(2);
+          expect(deleteRelations).toHaveBeenNthCalledWith(1, { id: 1 });
+          expect(deleteRelations).toHaveBeenNthCalledWith(2, { id: 2 });
+          expect(deleteMany).toHaveBeenCalledWith({ locale: { $ne: 'fr' } });
+          expect(updateMany).toHaveBeenCalledWith(
+            {},
+            { $unset: { locale: '' } },
+            { strict: false }
+          );
+        });
+      });
+    });
+  });
+});

package/config/functions/migrations/__tests__/field.test.js

@@ -0,0 +1,150 @@
+'use strict';
+
+const { after } = require('../field');
+
+describe('i18n - Migration - disable localization on a field', () => {
+  describe('after', () => {
+    describe('Should not migrate', () => {
+      test("Doesn't migrate if model isn't localized", async () => {
+        const find = jest.fn();
+        global.strapi = {
+          query: () => {
+            find;
+          },
+          plugins: {
+            i18n: {
+              services: {
+                'content-types': {
+                  isLocalizedContentType: () => false,
+                },
+              },
+            },
+          },
+        };
+
+        const model = {};
+        const previousDefinition = {};
+
+        await after({ model, definition: model, previousDefinition });
+        expect(find).not.toHaveBeenCalled();
+      });
+
+      test("Doesn't migrate if no attribute changed (without i18n)", async () => {
+        const find = jest.fn();
+        const getLocalizedAttributes = jest.fn(() => []);
+
+        global.strapi = {
+          query: () => {
+            find;
+          },
+          plugins: {
+            i18n: {
+              services: {
+                'content-types': {
+                  isLocalizedContentType: () => true,
+                  getLocalizedAttributes,
+                },
+              },
+            },
+          },
+        };
+
+        const model = { attributes: { name: {} } };
+        const previousDefinition = { attributes: { name: {} } };
+
+        await after({ model, definition: model, previousDefinition });
+        expect(getLocalizedAttributes).toHaveBeenCalledTimes(2);
+        expect(find).not.toHaveBeenCalled();
+      });
+
+      test("Doesn't migrate if no attribute changed (with i18n)", async () => {
+        const find = jest.fn();
+        const getLocalizedAttributes = jest.fn(() => ['name']);
+        global.strapi = {
+          query: () => {
+            find;
+          },
+          plugins: {
+            i18n: {
+              services: {
+                'content-types': {
+                  isLocalizedContentType: () => true,
+                  getLocalizedAttributes,
+                },
+              },
+            },
+          },
+        };
+
+        const model = { attributes: { name: {} } };
+        const previousDefinition = { attributes: { name: {} } };
+
+        await after({ model, definition: model, previousDefinition });
+        expect(getLocalizedAttributes).toHaveBeenCalledTimes(2);
+        expect(find).not.toHaveBeenCalled();
+      });
+
+      test("Doesn't migrate if field become localized", async () => {
+        const find = jest.fn();
+        const getLocalizedAttributes = jest
+          .fn()
+          .mockReturnValueOnce(['name'])
+          .mockReturnValueOnce([]);
+
+        global.strapi = {
+          query: () => {
+            find;
+          },
+          plugins: {
+            i18n: {
+              services: {
+                'content-types': {
+                  isLocalizedContentType: () => true,
+                  getLocalizedAttributes,
+                },
+              },
+            },
+          },
+        };
+
+        const model = { attributes: { name: {} } };
+        const previousDefinition = { attributes: { name: {} } };
+
+        await after({ model, definition: model, previousDefinition });
+        expect(getLocalizedAttributes).toHaveBeenCalledTimes(2);
+        expect(find).not.toHaveBeenCalled();
+      });
+
+      test("Doesn't migrate if field is deleted", async () => {
+        const find = jest.fn();
+        const getLocalizedAttributes = jest
+          .fn()
+          .mockReturnValueOnce([])
+          .mockReturnValueOnce(['name']);
+
+        global.strapi = {
+          query: () => {
+            find;
+          },
+          plugins: {
+            i18n: {
+              services: {
+                'content-types': {
+                  isLocalizedContentType: () => true,
+                  getLocalizedAttributes,
+                },
+              },
+            },
+          },
+        };
+
+        const model = { attributes: {} };
+        const previousDefinition = { attributes: { name: {} } };
+
+        await after({ model, definition: model, previousDefinition });
+        expect(getLocalizedAttributes).toHaveBeenCalledTimes(2);
+        expect(find).not.toHaveBeenCalled();
+      });
+    });
+  });
+});

package/config/functions/migrations/content-type/disable/index.js

@@ -0,0 +1,34 @@
+'use strict';
+
+const { getDefaultLocale } = require('../utils');
+const { getService } = require('../../../../../utils');
+
+const migrateForBookshelf = require('./migrate-for-bookshelf');
+const migrateForMongoose = require('./migrate-for-mongoose');
+
+const after = () => {};
+
+// Disable i18n on CT -> Delete all entities that are not in the default locale
+const before = async ({ model, definition, previousDefinition, ORM }, context) => {
+  const { isLocalizedContentType } = getService('content-types');
+
+  if (isLocalizedContentType(definition) || !isLocalizedContentType(previousDefinition)) {
+    return;
+  }
+
+  const defaultLocale = await getDefaultLocale(model, ORM);
+
+  if (model.orm === 'bookshelf') {
+    await migrateForBookshelf(
+      { ORM, defaultLocale, definition, previousDefinition, model },
+      context
+    );
+  } else if (model.orm === 'mongoose') {
+    await migrateForMongoose({ ORM, defaultLocale, model });
+  }
+};
+
+module.exports = {
+  before,
+  after,
+};