@akemona-org/strapi-plugin-i18n 3.7.0

package/services/entity-service-decorator.js

@@ -0,0 +1,155 @@
+'use strict';
+
+const { has, omit, isArray } = require('lodash/fp');
+const { getService } = require('../utils');
+
+const { syncLocalizations, syncNonLocalizedAttributes } = require('./localizations');
+
+const LOCALE_QUERY_FILTER = '_locale';
+const SINGLE_ENTRY_ACTIONS = ['findOne', 'update', 'delete'];
+const BULK_ACTIONS = ['delete'];
+
+const paramsContain = (key, params) => {
+  return (
+    has(key, params) ||
+    has(key, params._where) ||
+    (isArray(params._where) && params._where.some(clause => has(key, clause)))
+  );
+};
+
+/**
+ * Adds default locale or replaces _locale by locale in query params
+ * @param {object} params - query params
+ */
+const wrapParams = async (params = {}, ctx = {}) => {
+  const { action } = ctx;
+
+  if (has(LOCALE_QUERY_FILTER, params)) {
+    if (params[LOCALE_QUERY_FILTER] === 'all') {
+      return omit(LOCALE_QUERY_FILTER, params);
+    }
+
+    return {
+      ...omit(LOCALE_QUERY_FILTER, params),
+      locale: params[LOCALE_QUERY_FILTER],
+    };
+  }
+
+  const entityDefinedById = paramsContain('id', params) && SINGLE_ENTRY_ACTIONS.includes(action);
+  const entitiesDefinedByIds = paramsContain('id_in', params) && BULK_ACTIONS.includes(action);
+
+  if (entityDefinedById || entitiesDefinedByIds) {
+    return params;
+  }
+
+  const { getDefaultLocale } = getService('locales');
+
+  return {
+    ...params,
+    locale: await getDefaultLocale(),
+  };
+};
+
+/**
+ * Assigns a valid locale or the default one if not define
+ * @param {object} data
+ */
+const assignValidLocale = async data => {
+  const { getValidLocale } = getService('content-types');
+
+  try {
+    data.locale = await getValidLocale(data.locale);
+  } catch (e) {
+    throw strapi.errors.badRequest("This locale doesn't exist");
+  }
+};
+
+/**
+ * Decorates the entity service with I18N business logic
+ * @param {object} service - entity 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)
+   * @param {object} ctx - Query context
+   * @param {object} ctx.model - Model that is being used
+   */
+
+  async wrapOptions(opts = {}, ctx = {}) {
+    const wrappedOptions = await service.wrapOptions.call(this, opts, ctx);
+
+    const model = strapi.db.getModel(ctx.model);
+
+    const { isLocalizedContentType } = getService('content-types');
+
+    if (!isLocalizedContentType(model)) {
+      return wrappedOptions;
+    }
+
+    return {
+      ...wrappedOptions,
+      params: await wrapParams(wrappedOptions.params, ctx),
+    };
+  },
+
+  /**
+   * Creates an entry & make links between it and its related localizaionts
+   * @param {object} opts - Query options object (params, data, files, populate)
+   * @param {object} ctx - Query context
+   * @param {object} ctx.model - Model that is being used
+   */
+  async create(opts, ctx) {
+    const model = strapi.db.getModel(ctx.model);
+
+    const { isLocalizedContentType } = getService('content-types');
+
+    if (!isLocalizedContentType(model)) {
+      return service.create.call(this, opts, ctx);
+    }
+
+    const { data } = opts;
+    await assignValidLocale(data);
+
+    const entry = await service.create.call(this, opts, ctx);
+
+    await syncLocalizations(entry, { model });
+    await syncNonLocalizedAttributes(entry, { model });
+    return entry;
+  },
+
+  /**
+   * Updates an entry & update related localizations fields
+   * @param {object} opts - Query options object (params, data, files, populate)
+   * @param {object} ctx - Query context
+   * @param {object} ctx.model - Model that is being used
+   */
+  async update(opts, ctx) {
+    const model = strapi.db.getModel(ctx.model);
+
+    const { isLocalizedContentType } = getService('content-types');
+
+    if (!isLocalizedContentType(model)) {
+      return service.update.call(this, opts, ctx);
+    }
+
+    const { data, ...restOptions } = opts;
+
+    const entry = await service.update.call(
+      this,
+      {
+        data: omit(['locale', 'localizations'], data),
+        ...restOptions,
+      },
+      ctx
+    );
+
+    await syncNonLocalizedAttributes(entry, { model });
+    return entry;
+  },
+});
+
+module.exports = {
+  decorator,
+  wrapParams,
+};

package/services/iso-locales.js

@@ -0,0 +1,9 @@
+'use strict';
+
+const { isoLocales } = require('../constants');
+
+const getIsoLocales = () => isoLocales;
+
+module.exports = {
+  getIsoLocales,
+};

package/services/locales.js

@@ -0,0 +1,97 @@
+'use strict';
+
+const { isNil } = require('lodash/fp');
+const { DEFAULT_LOCALE } = require('../constants');
+const { getService } = require('../utils');
+
+const { getCoreStore } = require('../utils');
+
+const find = (...args) => strapi.query('locale', 'i18n').find(...args);
+
+const findById = id => strapi.query('locale', 'i18n').findOne({ id });
+
+const findByCode = code => strapi.query('locale', 'i18n').findOne({ code });
+
+const count = params => strapi.query('locale', 'i18n').count(params);
+
+const create = async locale => {
+  const result = await strapi.query('locale', 'i18n').create(locale);
+
+  getService('metrics').sendDidUpdateI18nLocalesEvent();
+
+  return result;
+};
+
+const update = async (params, updates) => {
+  const result = await strapi.query('locale', 'i18n').update(params, updates);
+
+  getService('metrics').sendDidUpdateI18nLocalesEvent();
+
+  return result;
+};
+
+const deleteFn = async ({ id }) => {
+  const localeToDelete = await strapi.query('locale', 'i18n').findOne({ id });
+
+  if (localeToDelete) {
+    await deleteAllLocalizedEntriesFor({ locale: localeToDelete.code });
+    const result = await strapi.query('locale', 'i18n').delete({ id });
+
+    getService('metrics').sendDidUpdateI18nLocalesEvent();
+
+    return result;
+  }
+
+  return localeToDelete;
+};
+
+const setDefaultLocale = ({ code }) => getCoreStore().set({ key: 'default_locale', value: code });
+
+const getDefaultLocale = () => getCoreStore().get({ key: 'default_locale' });
+
+const setIsDefault = async locales => {
+  if (isNil(locales)) {
+    return locales;
+  }
+
+  const actualDefault = await getDefaultLocale();
+
+  if (Array.isArray(locales)) {
+    return locales.map(locale => ({ ...locale, isDefault: actualDefault === locale.code }));
+  } else {
+    // single locale
+    return { ...locales, isDefault: actualDefault === locales.code };
+  }
+};
+
+const initDefaultLocale = async () => {
+  const existingLocalesNb = await strapi.query('locale', 'i18n').count();
+  if (existingLocalesNb === 0) {
+    await create(DEFAULT_LOCALE);
+    await setDefaultLocale({ code: DEFAULT_LOCALE.code });
+  }
+};
+
+const deleteAllLocalizedEntriesFor = async ({ locale }) => {
+  const { isLocalizedContentType } = getService('content-types');
+
+  const localizedModels = Object.values(strapi.contentTypes).filter(isLocalizedContentType);
+
+  for (const model of localizedModels) {
+    await strapi.query(model.uid).delete({ locale }, { returning: false });
+  }
+};
+
+module.exports = {
+  find,
+  findById,
+  findByCode,
+  create,
+  update,
+  count,
+  setDefaultLocale,
+  getDefaultLocale,
+  setIsDefault,
+  delete: deleteFn,
+  initDefaultLocale,
+};

package/services/localizations.js

@@ -0,0 +1,65 @@
+'use strict';
+
+const { prop, isNil, isEmpty } = require('lodash/fp');
+
+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 { getDefaultLocale } = getService('locales');
+
+  if (isNil(data.locale)) {
+    data.locale = await getDefaultLocale();
+  }
+};
+
+/**
+ * Syncronize related localizations from a root one
+ * @param {Object} entry entry to update
+ * @param {Object} options
+ * @param {Object} options.model corresponding model
+ */
+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);
+
+      return strapi.query(model.uid).update({ id }, { localizations });
+    };
+
+    await Promise.all(entry.localizations.map(({ id }) => updateLocalization(id)));
+  }
+};
+
+/**
+ * Update non localized fields of all the related localizations of an entry with the entry values
+ * @param {Object} entry entry to update
+ * @param {Object} options
+ * @param {Object} options.model corresponding model
+ */
+const syncNonLocalizedAttributes = async (entry, { model }) => {
+  const { copyNonLocalizedAttributes } = getService('content-types');
+
+  if (Array.isArray(entry.localizations)) {
+    const nonLocalizedAttributes = copyNonLocalizedAttributes(model, entry);
+
+    if (isEmpty(nonLocalizedAttributes)) {
+      return;
+    }
+
+    const updateLocalization = id => strapi.query(model.uid).update({ id }, nonLocalizedAttributes);
+
+    await Promise.all(entry.localizations.map(({ id }) => updateLocalization(id)));
+  }
+};
+
+module.exports = {
+  assignDefaultLocale,
+  syncLocalizations,
+  syncNonLocalizedAttributes,
+};

package/services/metrics.js

@@ -0,0 +1,24 @@
+'use strict';
+
+// const { reduce } = require('lodash/fp');
+// const { getService } = require('../utils');
+
+const sendDidInitializeEvent = async () => {
+  // const { isLocalizedContentType } = getService('content-types');
+  // const numberOfContentTypes = reduce(
+  //   (sum, contentType) => (isLocalizedContentType(contentType) ? sum + 1 : sum),
+  //   0
+  // )(strapi.contentTypes);
+  // await strapi.telemetry.send('didInitializeI18n', { numberOfContentTypes });
+};
+
+const sendDidUpdateI18nLocalesEvent = async () => {
+  /*  const numberOfLocales = await getService('locales').count();
+
+  await strapi.telemetry.send('didUpdateI18nLocales', { numberOfLocales }); */
+};
+
+module.exports = {
+  sendDidInitializeEvent,
+  sendDidUpdateI18nLocalesEvent,
+};

package/services/permissions/actions.js

@@ -0,0 +1,124 @@
+'use strict';
+
+const { capitalize, isArray, getOr, prop } = require('lodash/fp');
+const { getService } = require('../../utils');
+
+const actions = ['create', 'read', 'update', 'delete'].map(uid => ({
+  section: 'settings',
+  category: 'Internationalization',
+  subCategory: 'Locales',
+  pluginName: 'i18n',
+  displayName: capitalize(uid),
+  uid: `locale.${uid}`,
+}));
+
+const addLocalesPropertyIfNeeded = ({ value: action }) => {
+  const {
+    section,
+    options: { applyToProperties },
+  } = action;
+
+  // Only add the locales property to contentTypes' actions
+  if (section !== 'contentTypes') {
+    return;
+  }
+
+  // If the 'locales' property is already declared within the applyToProperties array, then ignore the next steps
+  if (isArray(applyToProperties) && applyToProperties.includes('locales')) {
+    return;
+  }
+
+  // Add the 'locales' property to the applyToProperties array (create it if necessary)
+  action.options.applyToProperties = isArray(applyToProperties)
+    ? applyToProperties.concat('locales')
+    : ['locales'];
+};
+
+const shouldApplyLocalesPropertyToSubject = ({ property, subject }) => {
+  if (property === 'locales') {
+    const model = strapi.getModel(subject);
+
+    return getService('content-types').isLocalizedContentType(model);
+  }
+
+  return true;
+};
+
+const addAllLocalesToPermissions = async permissions => {
+  const { actionProvider } = strapi.admin.services.permission;
+  const { find: findAllLocales } = getService('locales');
+
+  const allLocales = await findAllLocales();
+  const allLocalesCode = allLocales.map(prop('code'));
+
+  return Promise.all(
+    permissions.map(async permission => {
+      const { action, subject } = permission;
+
+      const appliesToLocalesProperty = await actionProvider.appliesToProperty(
+        'locales',
+        action,
+        subject
+      );
+
+      if (!appliesToLocalesProperty) {
+        return permission;
+      }
+
+      const oldPermissionProperties = getOr({}, 'properties', permission);
+
+      return { ...permission, properties: { ...oldPermissionProperties, locales: allLocalesCode } };
+    })
+  );
+};
+
+const syncSuperAdminPermissionsWithLocales = async () => {
+  const roleService = strapi.admin.services.role;
+  const permissionService = strapi.admin.services.permission;
+
+  const superAdminRole = await roleService.getSuperAdmin();
+
+  if (!superAdminRole) {
+    return;
+  }
+
+  const superAdminPermissions = await permissionService.findUserPermissions({
+    roles: [superAdminRole],
+  });
+
+  const newSuperAdminPermissions = await addAllLocalesToPermissions(superAdminPermissions);
+
+  await roleService.assignPermissions(superAdminRole.id, newSuperAdminPermissions);
+};
+
+const registerI18nActions = async () => {
+  const { actionProvider } = strapi.admin.services.permission;
+
+  await actionProvider.registerMany(actions);
+};
+
+const registerI18nActionsHooks = () => {
+  const { actionProvider } = strapi.admin.services.permission;
+  const { hooks } = strapi.admin.services.role;
+
+  actionProvider.hooks.appliesPropertyToSubject.register(shouldApplyLocalesPropertyToSubject);
+  hooks.willResetSuperAdminPermissions.register(addAllLocalesToPermissions);
+};
+
+const updateActionsProperties = () => {
+  const { actionProvider } = strapi.admin.services.permission;
+
+  // Register the transformation for every new action
+  actionProvider.hooks.willRegister.register(addLocalesPropertyIfNeeded);
+
+  // Handle already registered actions
+  actionProvider.values().forEach(action => addLocalesPropertyIfNeeded({ value: action }));
+};
+
+module.exports = {
+  actions,
+  registerI18nActions,
+  registerI18nActionsHooks,
+  updateActionsProperties,
+  syncSuperAdminPermissionsWithLocales,
+};

package/services/permissions/engine.js

@@ -0,0 +1,63 @@
+'use strict';
+
+const { getService } = require('../../utils');
+
+/**
+ * @typedef {object} WillRegisterPermissionContext
+ * @property {Permission} permission
+ * @property {object} user
+ * @property {object} condition
+ */
+
+/**
+ * Locales property handler for the permission engine
+ * Add the has-locale-access condition if the locales property is defined
+ * @param {WillRegisterPermissionContext} context
+ */
+const willRegisterPermission = context => {
+  const { permission, condition, user } = context;
+  const { subject, properties } = permission;
+
+  const isSuperAdmin = strapi.admin.services.role.hasSuperAdminRole(user);
+
+  if (isSuperAdmin) {
+    return;
+  }
+
+  const { locales } = properties || {};
+  const { isLocalizedContentType } = getService('content-types');
+
+  // If there is no subject defined, ignore the permission
+  if (!subject) {
+    return;
+  }
+
+  const ct = strapi.contentTypes[subject];
+
+  // If the subject exists but isn't localized, ignore the permission
+  if (!isLocalizedContentType(ct)) {
+    return;
+  }
+
+  // If the subject is localized but the locales property is null (access to all locales), ignore the permission
+  if (locales === null) {
+    return;
+  }
+
+  condition.and({
+    locale: {
+      $in: locales || [],
+    },
+  });
+};
+
+const registerI18nPermissionsHandlers = () => {
+  const { engine } = strapi.admin.services.permission;
+
+  engine.hooks.willRegisterPermission.register(willRegisterPermission);
+};
+
+module.exports = {
+  willRegisterPermission,
+  registerI18nPermissionsHandlers,
+};

package/services/permissions/sections-builder.js

@@ -0,0 +1,48 @@
+'use strict';
+
+const { isEmpty } = require('lodash/fp');
+
+const { getService } = require('../../utils');
+
+/**
+ * Handler for the permissions layout (sections builder)
+ * Adds the locales property to the subjects
+ * @param {Action} action
+ * @param {ContentTypesSection} section
+ * @return {Promise<void>}
+ */
+const localesPropertyHandler = async ({ action, section }) => {
+  const { actionProvider } = strapi.admin.services.permission;
+
+  const locales = await getService('locales').find();
+
+  // Do not add the locales property if there is none registered
+  if (isEmpty(locales)) {
+    return;
+  }
+
+  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');
+
+    if (applies && !hasLocalesProperty) {
+      subject.properties.push({
+        label: 'Locales',
+        value: 'locales',
+        children: locales.map(({ name, code }) => ({ label: name || code, value: code })),
+      });
+    }
+  }
+};
+
+const registerLocalesPropertyHandler = () => {
+  const { sectionsBuilder } = strapi.admin.services.permission;
+
+  sectionsBuilder.addHandler('singleTypes', localesPropertyHandler);
+  sectionsBuilder.addHandler('collectionTypes', localesPropertyHandler);
+};
+
+module.exports = {
+  localesPropertyHandler,
+  registerLocalesPropertyHandler,
+};

package/services/permissions.js

@@ -0,0 +1,11 @@
+'use strict';
+
+const i18nActionsService = require('./permissions/actions');
+const sectionsBuilderService = require('./permissions/sections-builder');
+const engineService = require('./permissions/engine');
+
+module.exports = {
+  actions: i18nActionsService,
+  sectionsBuilder: sectionsBuilderService,
+  engine: engineService,
+};