@akemona-org/strapi-plugin-i18n 3.7.0

package/config/functions/migrations/content-type/disable/migrate-for-bookshelf.js

@@ -0,0 +1,58 @@
+'use strict';
+
+const pmap = require('p-map');
+
+const BATCH_SIZE = 1000;
+
+const migrateForBookshelf = async (
+  { ORM, defaultLocale, definition, previousDefinition, model },
+  context
+) => {
+  const localizationsTable = `${previousDefinition.collectionName}__localizations`;
+  const trx = await ORM.knex.transaction();
+  try {
+    let offset = 0;
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+      let batch = await trx
+        .select(['id'])
+        .from(model.collectionName)
+        .whereNot('locale', defaultLocale)
+        .orderBy('id')
+        .offset(offset)
+        .limit(BATCH_SIZE);
+      offset += BATCH_SIZE;
+
+      await pmap(batch, entry => model.deleteRelations(entry.id, { transacting: trx }), {
+        concurrency: 100,
+        stopOnError: true,
+      });
+
+      if (batch.length < BATCH_SIZE) {
+        break;
+      }
+    }
+    await trx
+      .from(model.collectionName)
+      .del()
+      .whereNot('locale', defaultLocale);
+    await trx.commit();
+  } catch (e) {
+    await trx.rollback();
+    throw e;
+  }
+
+  if (definition.client === 'sqlite3') {
+    // Bug when dropping column with sqlite3 https://github.com/knex/knex/issues/631
+    // Need to recreate the table
+    context.recreateSqliteTable = true;
+  } else {
+    await ORM.knex.schema.table(definition.collectionName, t => {
+      t.dropColumn('locale');
+    });
+  }
+
+  await ORM.knex.schema.dropTableIfExists(localizationsTable);
+};
+
+module.exports = migrateForBookshelf;

package/config/functions/migrations/content-type/disable/migrate-for-mongoose.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const pmap = require('p-map');
+
+const BATCH_SIZE = 1000;
+
+const migrateForMongoose = async ({ model, defaultLocale }) => {
+  let lastId;
+  const findParams = { locale: { $ne: defaultLocale } };
+
+  // eslint-disable-next-line no-constant-condition
+  while (true) {
+    if (lastId) {
+      findParams._id = { $gt: lastId };
+    }
+
+    const batch = await model
+      .find(findParams, ['id'])
+      .sort({ _id: 1 })
+      .limit(BATCH_SIZE);
+
+    if (batch.length > 0) {
+      lastId = batch[batch.length - 1]._id;
+    }
+
+    await pmap(batch, entry => model.deleteRelations(entry), {
+      concurrency: 100,
+      stopOnError: true,
+    });
+
+    if (batch.length < BATCH_SIZE) {
+      break;
+    }
+  }
+  await model.deleteMany({ locale: { $ne: defaultLocale } });
+  await model.updateMany({}, { $unset: { locale: '' } }, { strict: false });
+};
+
+module.exports = migrateForMongoose;

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

@@ -0,0 +1,40 @@
+'use strict';
+
+const { getService } = require('../../../../../utils');
+const { getDefaultLocale } = require('../utils');
+
+const updateLocale = (model, ORM, locale) => {
+  if (model.orm === 'bookshelf') {
+    return ORM.knex
+      .update({ locale })
+      .from(model.collectionName)
+      .where({ locale: null });
+  }
+
+  if (model.orm === 'mongoose') {
+    return model.updateMany(
+      { $or: [{ locale: { $exists: false } }, { locale: null }] },
+      { locale }
+    );
+  }
+};
+
+// Enable i18n on CT -> Add default locale to all existing entities
+const after = async ({ model, definition, previousDefinition, ORM }) => {
+  const { isLocalizedContentType } = getService('content-types');
+
+  if (!isLocalizedContentType(definition) || isLocalizedContentType(previousDefinition)) {
+    return;
+  }
+
+  const defaultLocale = await getDefaultLocale(model, ORM);
+
+  await updateLocale(model, ORM, defaultLocale);
+};
+
+const before = () => {};
+
+module.exports = {
+  before,
+  after,
+};

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

@@ -0,0 +1,27 @@
+'use strict';
+
+const { DEFAULT_LOCALE } = require('../../../../../constants');
+
+const getDefaultLocale = async (model, ORM) => {
+  let defaultLocaleRows;
+  if (model.orm === 'bookshelf') {
+    defaultLocaleRows = await ORM.knex
+      .select('value')
+      .from('core_store')
+      .where({ key: 'plugin_i18n_default_locale' });
+  } else if (model.orm === 'mongoose') {
+    defaultLocaleRows = await strapi.models['core_store'].find({
+      key: 'plugin_i18n_default_locale',
+    });
+  }
+
+  if (defaultLocaleRows.length > 0) {
+    return JSON.parse(defaultLocaleRows[0].value);
+  }
+
+  return DEFAULT_LOCALE.code;
+};
+
+module.exports = {
+  getDefaultLocale,
+};

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

@@ -0,0 +1,53 @@
+'use strict';
+
+const { shouldBeProcessed, getUpdatesInfo } = require('../utils');
+
+describe('i18n - migration utils', () => {
+  describe('shouldBeProcessed', () => {
+    const testData = [
+      [[], [], false],
+      [['en'], [], false],
+      [['en', 'fr'], [], false],
+      [['en', 'fr'], [{ locale: 'en' }], false],
+      [['en', 'fr'], [{ locale: 'fr' }], false],
+      [['en'], [{ locale: 'fr' }, { locale: 'en' }], false],
+      [['en', 'fr'], [{ locale: 'fr' }, { locale: 'en' }], false],
+      [[], [{ locale: 'en' }], true],
+      [['en'], [{ locale: 'fr' }], true],
+      [['en', 'fr'], [{ locale: 'it' }], true],
+    ];
+
+    test.each(testData)('%p %j : %p', (processedLocaleCodes, localizations, expectedResult) => {
+      const result = shouldBeProcessed(processedLocaleCodes)({ localizations });
+
+      expect(result).toBe(expectedResult);
+    });
+  });
+
+  describe('getUpdatesInfo', () => {
+    const testData = [
+      [
+        [{ name: 'Name', nickname: 'Nickname', localizations: [{ id: 1 }, { id: 2 }] }],
+        ['name'],
+        [{ entriesIdsToUpdate: [1, 2], attributesValues: { name: 'Name' } }],
+      ],
+      [
+        [
+          { name: 'Name 1', nickname: 'Nickname 1', localizations: [{ id: 1 }, { id: 2 }] },
+          { name: 'Name 2', nickname: 'Nickname 2', localizations: [{ id: 3 }, { id: 4 }] },
+        ],
+        ['name'],
+        [
+          { entriesIdsToUpdate: [1, 2], attributesValues: { name: 'Name 1' } },
+          { entriesIdsToUpdate: [3, 4], attributesValues: { name: 'Name 2' } },
+        ],
+      ],
+    ];
+
+    test.each(testData)('%j', (entriesToProcess, attributesToMigrate, expectedResult) => {
+      const result = getUpdatesInfo({ entriesToProcess, attributesToMigrate });
+
+      expect(result).toEqual(expectedResult);
+    });
+  });
+});

package/config/functions/migrations/field/index.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const { difference, keys, intersection, isEmpty } = require('lodash/fp');
+const { getService } = require('../../../../utils');
+const migrateForMongoose = require('./migrate-for-mongoose');
+const migrateForBookshelf = require('./migrate-for-bookshelf');
+
+// Migration when i18n is disabled on a field of a content-type that have i18n enabled
+const after = async ({ model, definition, previousDefinition, ORM }) => {
+  const { isLocalizedContentType, getLocalizedAttributes } = getService('content-types');
+
+  if (!isLocalizedContentType(model) || !isLocalizedContentType(previousDefinition)) {
+    return;
+  }
+
+  const localizedAttributes = getLocalizedAttributes(definition);
+  const prevLocalizedAttributes = getLocalizedAttributes(previousDefinition);
+  const attributesDisabled = difference(prevLocalizedAttributes, localizedAttributes);
+  const attributesToMigrate = intersection(keys(definition.attributes), attributesDisabled);
+
+  if (isEmpty(attributesToMigrate)) {
+    return;
+  }
+
+  if (model.orm === 'bookshelf') {
+    await migrateForBookshelf({ ORM, model, attributesToMigrate });
+  } else if (model.orm === 'mongoose') {
+    await migrateForMongoose({ model, attributesToMigrate });
+  }
+};
+
+const before = () => {};
+
+module.exports = {
+  before,
+  after,
+};

package/config/functions/migrations/field/migrate-for-bookshelf.js

@@ -0,0 +1,72 @@
+'use strict';
+
+const { migrate } = require('./migrate');
+const { areScalarAttributesOnly } = require('./utils');
+
+const TMP_TABLE_NAME = '__tmp__i18n_field_migration';
+
+const batchInsertInTmpTable = async ({ updatesInfo }, { transacting: trx }) => {
+  const tmpEntries = [];
+  updatesInfo.forEach(({ entriesIdsToUpdate, attributesValues }) => {
+    entriesIdsToUpdate.forEach(id => {
+      tmpEntries.push({ id, ...attributesValues });
+    });
+  });
+  await trx.batchInsert(TMP_TABLE_NAME, tmpEntries, 100);
+};
+
+const updateFromTmpTable = async ({ model, attributesToMigrate }, { transacting: trx }) => {
+  const collectionName = model.collectionName;
+  if (model.client === 'pg') {
+    const substitutes = attributesToMigrate.map(() => '?? = ??.??').join(',');
+    const bindings = [collectionName];
+    attributesToMigrate.forEach(attr => bindings.push(attr, TMP_TABLE_NAME, attr));
+    bindings.push(TMP_TABLE_NAME, collectionName, TMP_TABLE_NAME);
+
+    await trx.raw(`UPDATE ?? SET ${substitutes} FROM ?? WHERE ??.id = ??.id;`, bindings);
+  } else if (model.client === 'mysql') {
+    const substitutes = attributesToMigrate.map(() => '??.?? = ??.??').join(',');
+    const bindings = [collectionName, TMP_TABLE_NAME, collectionName, TMP_TABLE_NAME];
+    attributesToMigrate.forEach(attr => bindings.push(collectionName, attr, TMP_TABLE_NAME, attr));
+
+    await trx.raw(`UPDATE ?? JOIN ?? ON ??.id = ??.id SET ${substitutes};`, bindings);
+  }
+};
+
+const createTmpTable = async ({ ORM, attributesToMigrate, model }) => {
+  const columnsToCopy = ['id', ...attributesToMigrate];
+  await deleteTmpTable({ ORM });
+  await ORM.knex.raw(`CREATE TABLE ?? AS ??`, [
+    TMP_TABLE_NAME,
+    ORM.knex
+      .select(columnsToCopy)
+      .from(model.collectionName)
+      .whereRaw('?', 0),
+  ]);
+};
+
+const deleteTmpTable = ({ ORM }) => ORM.knex.schema.dropTableIfExists(TMP_TABLE_NAME);
+
+const migrateForBookshelf = async ({ ORM, model, attributesToMigrate }) => {
+  const onlyScalarAttrs = areScalarAttributesOnly({ model, attributes: attributesToMigrate });
+
+  // optimize migration for pg and mysql when there are only scalar attributes to migrate
+  if (onlyScalarAttrs && ['pg', 'mysql'].includes(model.client)) {
+    // create table outside of the transaction because mysql doesn't accept the creation inside
+    await createTmpTable({ ORM, attributesToMigrate, model });
+    await ORM.knex.transaction(async transacting => {
+      await migrate(
+        { model, attributesToMigrate },
+        { migrateFn: batchInsertInTmpTable, transacting }
+      );
+      await updateFromTmpTable({ model, attributesToMigrate }, { transacting });
+    });
+    await deleteTmpTable({ ORM });
+  } else {
+    await ORM.knex.transaction(async transacting => {
+      await migrate({ model, attributesToMigrate }, { transacting });
+    });
+  }
+};
+
+module.exports = migrateForBookshelf;

package/config/functions/migrations/field/migrate-for-mongoose.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const { migrate } = require('./migrate');
+const { areScalarAttributesOnly } = require('./utils');
+
+const batchUpdate = async ({ updatesInfo, model }) => {
+  const updates = updatesInfo.map(({ entriesIdsToUpdate, attributesValues }) => ({
+    updateMany: { filter: { _id: { $in: entriesIdsToUpdate } }, update: attributesValues },
+  }));
+
+  await model.bulkWrite(updates);
+};
+
+const migrateForMongoose = async ({ model, attributesToMigrate }) => {
+  const onlyScalarAttrs = areScalarAttributesOnly({ model, attributes: attributesToMigrate });
+
+  if (onlyScalarAttrs) {
+    await migrate({ model, attributesToMigrate }, { migrateFn: batchUpdate });
+  } else {
+    await migrate({ model, attributesToMigrate });
+  }
+};
+
+module.exports = migrateForMongoose;

package/config/functions/migrations/field/migrate.js

@@ -0,0 +1,55 @@
+'use strict';
+
+const { pick, prop } = require('lodash/fp');
+const { getService } = require('../../../../utils');
+const { shouldBeProcessed, getUpdatesInfo, getSortedLocales } = require('./utils');
+
+const BATCH_SIZE = 1000;
+
+const migrateBatch = async (entries, { model, attributesToMigrate }, { transacting }) => {
+  const { copyNonLocalizedAttributes } = getService('content-types');
+
+  const updatePromises = entries.map(entity => {
+    const updateValues = pick(attributesToMigrate, copyNonLocalizedAttributes(model, entity));
+    const entriesIdsToUpdate = entity.localizations.map(prop('id'));
+    return Promise.all(
+      entriesIdsToUpdate.map(id =>
+        strapi.query(model.uid).update({ id }, updateValues, { transacting })
+      )
+    );
+  });
+
+  await Promise.all(updatePromises);
+};
+
+const migrate = async ({ model, attributesToMigrate }, { migrateFn, transacting } = {}) => {
+  const locales = await getSortedLocales({ transacting });
+  const processedLocaleCodes = [];
+  for (const locale of locales) {
+    let offset = 0;
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+      const entries = await strapi
+        .query(model.uid)
+        .find({ locale, _start: offset, _limit: BATCH_SIZE }, null, { transacting });
+      const entriesToProcess = entries.filter(shouldBeProcessed(processedLocaleCodes));
+
+      if (migrateFn) {
+        const updatesInfo = getUpdatesInfo({ entriesToProcess, attributesToMigrate });
+        await migrateFn({ updatesInfo, model }, { transacting });
+      } else {
+        await migrateBatch(entriesToProcess, { model, attributesToMigrate }, { transacting });
+      }
+
+      if (entries.length < BATCH_SIZE) {
+        break;
+      }
+      offset += BATCH_SIZE;
+    }
+    processedLocaleCodes.push(locale);
+  }
+};
+
+module.exports = {
+  migrate,
+};

package/config/functions/migrations/field/utils.js

@@ -0,0 +1,58 @@
+'use strict';
+
+const { isScalarAttribute } = require('@akemona-org/strapi-utils').contentTypes;
+const { pick, prop, map, intersection, isEmpty, orderBy, pipe, every } = require('lodash/fp');
+const { getService } = require('../../../../utils');
+
+const shouldBeProcessed = (processedLocaleCodes) => (entry) => {
+  return (
+    entry.localizations.length > 0 &&
+    intersection(entry.localizations.map(prop('locale')), processedLocaleCodes).length === 0
+  );
+};
+
+const getUpdatesInfo = ({ entriesToProcess, attributesToMigrate }) => {
+  const updates = [];
+  for (const entry of entriesToProcess) {
+    const attributesValues = pick(attributesToMigrate, entry);
+    const entriesIdsToUpdate = entry.localizations.map(prop('id'));
+    updates.push({ entriesIdsToUpdate, attributesValues });
+  }
+  return updates;
+};
+
+const getSortedLocales = async ({ transacting } = {}) => {
+  const localeService = getService('locales');
+
+  let defaultLocale;
+  try {
+    const storeRes = await strapi
+      .query('core_store')
+      .findOne({ key: 'plugin_i18n_default_locale' }, null, { transacting });
+    defaultLocale = JSON.parse(storeRes.value);
+  } catch (e) {
+    throw new Error("Could not migrate because the default locale doesn't exist");
+  }
+
+  const locales = await localeService.find({}, null, { transacting });
+  if (isEmpty(locales)) {
+    throw new Error('Could not migrate because no locale exist');
+  }
+
+  // Put default locale first
+  return pipe(
+    map((locale) => ({ code: locale.code, isDefault: locale.code === defaultLocale })),
+    orderBy(['isDefault', 'code'], ['desc', 'asc']),
+    map(prop('code'))
+  )(locales);
+};
+
+const areScalarAttributesOnly = ({ model, attributes }) =>
+  pipe(pick(attributes), every(isScalarAttribute))(model.attributes);
+
+module.exports = {
+  shouldBeProcessed,
+  getUpdatesInfo,
+  getSortedLocales,
+  areScalarAttributesOnly,
+};

package/config/functions/register.js

@@ -0,0 +1,46 @@
+'use strict';
+
+const _ = require('lodash');
+const { PUBLISHED_AT_ATTRIBUTE } = require('@akemona-org/strapi-utils').contentTypes.constants;
+
+const { getService } = require('../../utils');
+const fieldMigration = require('./migrations/field');
+const enableContentTypeMigration = require('./migrations/content-type/enable');
+const disableContentTypeMigration = require('./migrations/content-type/disable');
+
+module.exports = () => {
+  const contentTypeService = getService('content-types');
+  const coreApiService = getService('core-api');
+
+  _.set(strapi.plugins.i18n.config, 'schema.graphql', {});
+
+  Object.values(strapi.contentTypes).forEach((contentType) => {
+    if (contentTypeService.isLocalizedContentType(contentType)) {
+      const { attributes, modelName } = contentType;
+
+      _.set(attributes, 'localizations', {
+        writable: true,
+        private: false,
+        configurable: false,
+        visible: false,
+        collection: modelName,
+        populate: ['_id', 'id', 'locale', PUBLISHED_AT_ATTRIBUTE],
+      });
+
+      _.set(attributes, 'locale', {
+        writable: true,
+        private: false,
+        configurable: false,
+        visible: false,
+        type: 'string',
+      });
+
+      coreApiService.addCreateLocalizationAction(contentType);
+      coreApiService.addGraphqlLocalizationAction(contentType);
+    }
+  });
+
+  strapi.db.migrations.register(fieldMigration);
+  strapi.db.migrations.register(enableContentTypeMigration);
+  strapi.db.migrations.register(disableContentTypeMigration);
+};

package/config/policies/validateLocaleCreation.js

@@ -0,0 +1,68 @@
+'use strict';
+
+const { get } = require('lodash/fp');
+const { getService } = require('../../utils');
+
+const validateLocaleCreation = async (ctx, next) => {
+  const { model } = ctx.params;
+  const { query, body } = ctx.request;
+
+  const {
+    getValidLocale,
+    getNewLocalizationsFrom,
+    isLocalizedContentType,
+    getAndValidateRelatedEntity,
+    fillNonLocalizedAttributes,
+  } = getService('content-types');
+
+  const modelDef = strapi.getModel(model);
+
+  if (!isLocalizedContentType(modelDef)) {
+    return next();
+  }
+
+  const locale = get('plugins.i18n.locale', query);
+  const relatedEntityId = get('plugins.i18n.relatedEntityId', query);
+  // cleanup to avoid creating duplicates in singletypes
+  ctx.request.query = {};
+
+  let entityLocale;
+  try {
+    entityLocale = await getValidLocale(locale);
+  } catch (e) {
+    return ctx.badRequest("This locale doesn't exist");
+  }
+
+  body.locale = entityLocale;
+
+  if (modelDef.kind === 'singleType') {
+    const entity = await strapi.entityService.find(
+      { params: { _locale: entityLocale } },
+      { model }
+    );
+
+    ctx.request.query._locale = body.locale;
+
+    // updating
+    if (entity) {
+      return next();
+    }
+  }
+
+  let relatedEntity;
+  try {
+    relatedEntity = await getAndValidateRelatedEntity(relatedEntityId, model, entityLocale);
+  } catch (e) {
+    return ctx.badRequest(
+      "The related entity doesn't exist or the entity already exists in this locale"
+    );
+  }
+
+  fillNonLocalizedAttributes(body, relatedEntity, { model });
+  const localizations = await getNewLocalizationsFrom(relatedEntity);
+  body.localizations = localizations;
+
+  return next();
+};
+
+module.exports = validateLocaleCreation;

package/config/routes.json

@@ -0,0 +1,64 @@
+{
+  "routes": [
+    {
+      "method": "GET",
+      "path": "/iso-locales",
+      "handler": "iso-locales.listIsoLocales",
+      "config": {
+        "policies": [
+          "admin::isAuthenticatedAdmin",
+          ["plugins::content-manager.hasPermissions", ["plugins::i18n.locale.read"]]
+        ]
+      }
+    },
+    {
+      "method": "GET",
+      "path": "/locales",
+      "handler": "locales.listLocales",
+      "config": {
+        "policies": []
+      }
+    },
+    {
+      "method": "POST",
+      "path": "/locales",
+      "handler": "locales.createLocale",
+      "config": {
+        "policies": [
+          "admin::isAuthenticatedAdmin",
+          ["plugins::content-manager.hasPermissions", ["plugins::i18n.locale.create"]]
+        ]
+      }
+    },
+    {
+      "method": "PUT",
+      "path": "/locales/:id",
+      "handler": "locales.updateLocale",
+      "config": {
+        "policies": [
+          "admin::isAuthenticatedAdmin",
+          ["plugins::content-manager.hasPermissions", ["plugins::i18n.locale.update"]]
+        ]
+      }
+    },
+    {
+      "method": "DELETE",
+      "path": "/locales/:id",
+      "handler": "locales.deleteLocale",
+      "config": {
+        "policies": [
+          "admin::isAuthenticatedAdmin",
+          ["plugins::content-manager.hasPermissions", ["plugins::i18n.locale.delete"]]
+        ]
+      }
+    },
+    {
+      "method": "POST",
+      "path": "/content-manager/actions/get-non-localized-fields",
+      "handler": "content-types.getNonLocalizedAttributes",
+      "config": {
+        "policies": ["admin::isAuthenticatedAdmin"]
+      }
+    }
+  ]
+}

package/constants/__tests__/index.test.js

@@ -0,0 +1,27 @@
+'use strict';
+
+const { getInitLocale } = require('../');
+
+describe('I18N default locale', () => {
+  describe('getInitLocale', () => {
+    test('The init locale is english by default', () => {
+      expect(getInitLocale()).toStrictEqual({
+        code: 'en',
+        name: 'English (en)',
+      });
+    });
+
+    test('The init locale can be configured by an env var', () => {
+      process.env.STRAPI_PLUGIN_I18N_INIT_LOCALE_CODE = 'fr';
+      expect(getInitLocale()).toStrictEqual({
+        code: 'fr',
+        name: 'French (fr)',
+      });
+    });
+
+    test('Throws if env var code is unknown in iso list', () => {
+      process.env.STRAPI_PLUGIN_I18N_INIT_LOCALE_CODE = 'zzzzz';
+      expect(() => getInitLocale()).toThrow();
+    });
+  });
+});