@strapi/i18n 0.0.0-experimental.f2351bcfa3965c60f063a492da51faa2c636eee8 → 0.0.0-experimental.f49f46a1c17445a39e8af3f63124bcccf73842e6

package/dist/server/index.js

@@ -65,12 +65,10 @@ const registerModelsHooks = () => {
     return result;
   });
 };
-const bootstrap = async ({ strapi: strapi2 }) => {
+const bootstrap = async () => {
   const { sendDidInitializeEvent: sendDidInitializeEvent2 } = getService("metrics");
-  const { decorator: decorator2 } = getService("entity-service-decorator");
   const { initDefaultLocale: initDefaultLocale2 } = getService("locales");
   const { sectionsBuilder, actions: actions2, engine } = getService("permissions");
-  strapi2.entityService.decorate(decorator2);
   await initDefaultLocale2();
   sectionsBuilder.registerLocalesPropertyHandler();
   await actions2.registerI18nActions();
@@ -197,6 +195,352 @@ const getI18nLocaleArgPlugin = ({ nexus, typeRegistry }) => {
     }
   });
 };
+const register = ({ strapi: strapi2 }) => {
+  extendContentTypes(strapi2);
+  addContentManagerLocaleMiddleware(strapi2);
+};
+const addContentManagerLocaleMiddleware = (strapi2) => {
+  strapi2.server.router.use("/content-manager/collection-types/:model", (ctx, next) => {
+    if (ctx.method === "POST" || ctx.method === "PUT") {
+      return validateLocaleCreation(ctx, next);
+    }
+    return next();
+  });
+  strapi2.server.router.use("/content-manager/single-types/:model", (ctx, next) => {
+    if (ctx.method === "POST" || ctx.method === "PUT") {
+      return validateLocaleCreation(ctx, next);
+    }
+    return next();
+  });
+};
+const extendContentTypes = (strapi2) => {
+  const { isLocalizedContentType: isLocalizedContentType2 } = getService("content-types");
+  Object.values(strapi2.contentTypes).forEach((contentType) => {
+    const { attributes: attributes2 } = contentType;
+    const isLocalized = isLocalizedContentType2(contentType);
+    ___default.default.set(attributes2, "locale", {
+      writable: true,
+      private: !isLocalized,
+      configurable: false,
+      visible: false,
+      type: "string"
+    });
+    ___default.default.set(attributes2, "localizations", {
+      type: "relation",
+      relation: "oneToMany",
+      target: contentType.uid,
+      writable: false,
+      private: !isLocalized,
+      configurable: false,
+      visible: false,
+      unstable_virtual: true,
+      joinColumn: {
+        name: "document_id",
+        referencedColumn: "document_id",
+        referencedTable: strapi2.db.metadata.identifiers.getTableName(contentType.collectionName),
+        // ensure the population will not include the results we already loaded
+        on({ results }) {
+          return {
+            id: {
+              $notIn: results.map((r) => r.id)
+            }
+          };
+        }
+      }
+    });
+  });
+  if (strapi2.plugin("graphql")) {
+    graphqlProvider({ strapi: strapi2 }).register();
+  }
+};
+const info = {
+  singularName: "locale",
+  pluralName: "locales",
+  collectionName: "locales",
+  displayName: "Locale",
+  description: ""
+};
+const options = {};
+const pluginOptions = {
+  "content-manager": {
+    visible: false
+  },
+  "content-type-builder": {
+    visible: false
+  }
+};
+const attributes = {
+  name: {
+    type: "string",
+    min: 1,
+    max: 50,
+    configurable: false
+  },
+  code: {
+    type: "string",
+    unique: true,
+    configurable: false
+  }
+};
+const schema = {
+  info,
+  options,
+  pluginOptions,
+  attributes
+};
+const locale = {
+  schema
+};
+const contentTypes$1 = {
+  locale
+};
+const actions = [
+  {
+    section: "settings",
+    category: "Internationalization",
+    subCategory: "Locales",
+    pluginName: "i18n",
+    displayName: "Create",
+    uid: "locale.create"
+  },
+  {
+    section: "settings",
+    category: "Internationalization",
+    subCategory: "Locales",
+    pluginName: "i18n",
+    displayName: "Read",
+    uid: "locale.read",
+    aliases: [
+      { actionId: "plugin::content-manager.explorer.read", subjects: ["plugin::i18n.locale"] }
+    ]
+  },
+  {
+    section: "settings",
+    category: "Internationalization",
+    subCategory: "Locales",
+    pluginName: "i18n",
+    displayName: "Update",
+    uid: "locale.update"
+  },
+  {
+    section: "settings",
+    category: "Internationalization",
+    subCategory: "Locales",
+    pluginName: "i18n",
+    displayName: "Delete",
+    uid: "locale.delete"
+  }
+];
+const addLocalesPropertyIfNeeded = ({ value: action }) => {
+  const {
+    section,
+    options: { applyToProperties }
+  } = action;
+  if (section !== "contentTypes") {
+    return;
+  }
+  if (fp.isArray(applyToProperties) && applyToProperties.includes("locales")) {
+    return;
+  }
+  action.options.applyToProperties = fp.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 (permissions2) => {
+  const { actionProvider } = strapi.service("admin::permission");
+  const { find: findAllLocales } = getService("locales");
+  const allLocales = await findAllLocales();
+  const allLocalesCode = allLocales.map(fp.prop("code"));
+  return Promise.all(
+    permissions2.map(async (permission) => {
+      const { action, subject } = permission;
+      const appliesToLocalesProperty = await actionProvider.appliesToProperty(
+        "locales",
+        action,
+        subject
+      );
+      if (!appliesToLocalesProperty) {
+        return permission;
+      }
+      const oldPermissionProperties = fp.getOr({}, "properties", permission);
+      return { ...permission, properties: { ...oldPermissionProperties, locales: allLocalesCode } };
+    })
+  );
+};
+const syncSuperAdminPermissionsWithLocales = async () => {
+  const roleService = strapi.service("admin::role");
+  const permissionService = strapi.service("admin::permission");
+  const superAdminRole = await roleService.getSuperAdmin();
+  if (!superAdminRole) {
+    return;
+  }
+  const superAdminPermissions = await permissionService.findMany({
+    where: {
+      role: {
+        id: superAdminRole.id
+      }
+    }
+  });
+  const newSuperAdminPermissions = await addAllLocalesToPermissions(superAdminPermissions);
+  await roleService.assignPermissions(superAdminRole.id, newSuperAdminPermissions);
+};
+const registerI18nActions = async () => {
+  const { actionProvider } = strapi.service("admin::permission");
+  await actionProvider.registerMany(actions);
+};
+const registerI18nActionsHooks = () => {
+  const { actionProvider } = strapi.service("admin::permission");
+  const { hooks } = strapi.service("admin::role");
+  actionProvider.hooks.appliesPropertyToSubject.register(shouldApplyLocalesPropertyToSubject);
+  hooks.willResetSuperAdminPermissions.register(addAllLocalesToPermissions);
+};
+const updateActionsProperties = () => {
+  const { actionProvider } = strapi.service("admin::permission");
+  actionProvider.hooks.willRegister.register(addLocalesPropertyIfNeeded);
+  actionProvider.values().forEach((action) => addLocalesPropertyIfNeeded({ value: action }));
+};
+const i18nActionsService = {
+  actions,
+  registerI18nActions,
+  registerI18nActionsHooks,
+  updateActionsProperties,
+  syncSuperAdminPermissionsWithLocales
+};
+const localesPropertyHandler = async ({ action, section }) => {
+  const { actionProvider } = strapi.service("admin::permission");
+  const locales2 = await getService("locales").find();
+  if (fp.isEmpty(locales2)) {
+    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: locales2.map(({ name, code }) => ({ label: name || code, value: code }))
+      });
+    }
+  }
+};
+const registerLocalesPropertyHandler = () => {
+  const { sectionsBuilder } = strapi.service("admin::permission");
+  sectionsBuilder.addHandler("singleTypes", localesPropertyHandler);
+  sectionsBuilder.addHandler("collectionTypes", localesPropertyHandler);
+};
+const sectionsBuilderService = {
+  localesPropertyHandler,
+  registerLocalesPropertyHandler
+};
+const willRegisterPermission = (context) => {
+  const { permission, condition, user } = context;
+  const { subject, properties } = permission;
+  const isSuperAdmin = strapi.service("admin::role").hasSuperAdminRole(user);
+  if (isSuperAdmin) {
+    return;
+  }
+  const { locales: locales2 } = properties || {};
+  const { isLocalizedContentType: isLocalizedContentType2 } = getService("content-types");
+  if (!subject) {
+    return;
+  }
+  const ct = strapi.contentTypes[subject];
+  if (!isLocalizedContentType2(ct)) {
+    return;
+  }
+  if (locales2 === null) {
+    return;
+  }
+  condition.and({
+    locale: {
+      $in: locales2 || []
+    }
+  });
+};
+const registerI18nPermissionsHandlers = () => {
+  const { engine } = strapi.service("admin::permission");
+  engine.hooks["before-register.permission"].register(willRegisterPermission);
+};
+const engineService = {
+  willRegisterPermission,
+  registerI18nPermissionsHandlers
+};
+const permissions = () => ({
+  actions: i18nActionsService,
+  sectionsBuilder: sectionsBuilderService,
+  engine: engineService
+});
+const sendDidInitializeEvent = async () => {
+  const { isLocalizedContentType: isLocalizedContentType2 } = getService("content-types");
+  const numberOfContentTypes = fp.reduce(
+    (sum, contentType) => isLocalizedContentType2(contentType) ? sum + 1 : sum,
+    0
+  )(strapi.contentTypes);
+  await strapi.telemetry.send("didInitializeI18n", { groupProperties: { numberOfContentTypes } });
+};
+const sendDidUpdateI18nLocalesEvent = async () => {
+  const numberOfLocales = await getService("locales").count();
+  await strapi.telemetry.send("didUpdateI18nLocales", {
+    groupProperties: { numberOfLocales }
+  });
+};
+const metrics = () => ({
+  sendDidInitializeEvent,
+  sendDidUpdateI18nLocalesEvent
+});
+const syncNonLocalizedAttributes = async (sourceEntry, model) => {
+  const { copyNonLocalizedAttributes: copyNonLocalizedAttributes2 } = getService("content-types");
+  const nonLocalizedAttributes = copyNonLocalizedAttributes2(model, sourceEntry);
+  if (fp.isEmpty(nonLocalizedAttributes)) {
+    return;
+  }
+  const uid = model.uid;
+  const documentId = sourceEntry.documentId;
+  const locale2 = sourceEntry.locale;
+  const status = sourceEntry?.publishedAt ? "published" : "draft";
+  const localeEntriesToUpdate = await strapi.db.query(uid).findMany({
+    where: {
+      documentId,
+      publishedAt: status === "published" ? { $ne: null } : null,
+      locale: { $ne: locale2 }
+    },
+    select: ["locale", "id"]
+  });
+  const entryData = await strapi.documents(uid).omitComponentData(nonLocalizedAttributes);
+  await utils.async.map(localeEntriesToUpdate, async (entry) => {
+    const transformedData = await strapi.documents.utils.transformData(
+      fp.cloneDeep(nonLocalizedAttributes),
+      {
+        uid,
+        status,
+        locale: entry.locale,
+        allowMissingId: true
+      }
+    );
+    const componentData = await strapi.documents(uid).updateComponents(entry, transformedData);
+    await strapi.db.query(uid).update({
+      where: {
+        documentId,
+        publishedAt: status === "published" ? { $ne: null } : null,
+        locale: { $eq: entry.locale }
+      },
+      // The data we send to the update function is the entry data merged with
+      // the updated component data
+      data: Object.assign(fp.cloneDeep(entryData), componentData)
+    });
+  });
+};
+const localizations = () => ({
+  syncNonLocalizedAttributes
+});
 const isoLocales = [
   {
     code: "af",
@@ -2596,409 +2940,34 @@ const isoLocales = [
   },
   {
     code: "dje-NE",
-    name: "Zarma (Niger) (dje-NE)"
-  },
-  {
-    code: "zu",
-    name: "Zulu (zu)"
-  },
-  {
-    code: "zu-ZA",
-    name: "Zulu (South Africa) (zu-ZA)"
-  }
-];
-const getInitLocale = () => {
-  const envLocaleCode = process.env.STRAPI_PLUGIN_I18N_INIT_LOCALE_CODE;
-  if (envLocaleCode) {
-    const matchingLocale = isoLocales.find(({ code }) => code === envLocaleCode);
-    if (!matchingLocale) {
-      throw new Error(
-        "Unknown locale code provided in the environment variable STRAPI_PLUGIN_I18N_INIT_LOCALE_CODE"
-      );
-    }
-    return { ...matchingLocale };
-  }
-  return {
-    code: "en",
-    name: "English (en)"
-  };
-};
-const DEFAULT_LOCALE = getInitLocale();
-const enableContentType = async ({ oldContentTypes, contentTypes: contentTypes2 }) => {
-  const { isLocalizedContentType: isLocalizedContentType2 } = getService("content-types");
-  const { getDefaultLocale: getDefaultLocale2 } = getService("locales");
-  if (!oldContentTypes) {
-    return;
-  }
-  for (const uid in contentTypes2) {
-    if (!oldContentTypes[uid]) {
-      continue;
-    }
-    const oldContentType = oldContentTypes[uid];
-    const contentType = contentTypes2[uid];
-    if (!isLocalizedContentType2(oldContentType) && isLocalizedContentType2(contentType)) {
-      const defaultLocale = await getDefaultLocale2() || DEFAULT_LOCALE.code;
-      await strapi.db.query(uid).updateMany({
-        where: { locale: null },
-        data: { locale: defaultLocale }
-      });
-    }
-  }
-};
-const disableContentType = async ({ oldContentTypes, contentTypes: contentTypes2 }) => {
-  const { isLocalizedContentType: isLocalizedContentType2 } = getService("content-types");
-  const { getDefaultLocale: getDefaultLocale2 } = getService("locales");
-  if (!oldContentTypes) {
-    return;
-  }
-  for (const uid in contentTypes2) {
-    if (!oldContentTypes[uid]) {
-      continue;
-    }
-    const oldContentType = oldContentTypes[uid];
-    const contentType = contentTypes2[uid];
-    if (isLocalizedContentType2(oldContentType) && !isLocalizedContentType2(contentType)) {
-      const defaultLocale = await getDefaultLocale2() || DEFAULT_LOCALE.code;
-      await Promise.all([
-        // Delete all entities that are not in the default locale
-        strapi.db.query(uid).deleteMany({
-          where: { locale: { $ne: defaultLocale } }
-        }),
-        // Set locale to null for the rest
-        strapi.db.query(uid).updateMany({
-          where: { locale: { $eq: defaultLocale } },
-          data: { locale: null }
-        })
-      ]);
-    }
-  }
-};
-const register = ({ strapi: strapi2 }) => {
-  extendContentTypes(strapi2);
-  addContentManagerLocaleMiddleware(strapi2);
-  addContentTypeSyncHooks(strapi2);
-};
-const addContentManagerLocaleMiddleware = (strapi2) => {
-  strapi2.server.router.use("/content-manager/collection-types/:model", (ctx, next) => {
-    if (ctx.method === "POST" || ctx.method === "PUT") {
-      return validateLocaleCreation(ctx, next);
-    }
-    return next();
-  });
-  strapi2.server.router.use("/content-manager/single-types/:model", (ctx, next) => {
-    if (ctx.method === "POST" || ctx.method === "PUT") {
-      return validateLocaleCreation(ctx, next);
-    }
-    return next();
-  });
-};
-const addContentTypeSyncHooks = (strapi2) => {
-  strapi2.hook("strapi::content-types.beforeSync").register(disableContentType);
-  strapi2.hook("strapi::content-types.afterSync").register(enableContentType);
-};
-const extendContentTypes = (strapi2) => {
-  Object.values(strapi2.contentTypes).forEach((contentType) => {
-    const { attributes: attributes2 } = contentType;
-    ___default.default.set(attributes2, "locale", {
-      writable: true,
-      private: false,
-      configurable: false,
-      visible: false,
-      type: "string"
-    });
-  });
-  if (strapi2.plugin("graphql")) {
-    graphqlProvider({ strapi: strapi2 }).register();
-  }
-};
-const info = {
-  singularName: "locale",
-  pluralName: "locales",
-  collectionName: "locales",
-  displayName: "Locale",
-  description: ""
-};
-const options = {};
-const pluginOptions = {
-  "content-manager": {
-    visible: false
-  },
-  "content-type-builder": {
-    visible: false
-  }
-};
-const attributes = {
-  name: {
-    type: "string",
-    min: 1,
-    max: 50,
-    configurable: false
-  },
-  code: {
-    type: "string",
-    unique: true,
-    configurable: false
-  }
-};
-const schema = {
-  info,
-  options,
-  pluginOptions,
-  attributes
-};
-const locale = {
-  schema
-};
-const contentTypes$1 = {
-  locale
-};
-const actions = [
-  {
-    section: "settings",
-    category: "Internationalization",
-    subCategory: "Locales",
-    pluginName: "i18n",
-    displayName: "Create",
-    uid: "locale.create"
-  },
-  {
-    section: "settings",
-    category: "Internationalization",
-    subCategory: "Locales",
-    pluginName: "i18n",
-    displayName: "Read",
-    uid: "locale.read",
-    aliases: [
-      { actionId: "plugin::content-manager.explorer.read", subjects: ["plugin::i18n.locale"] }
-    ]
-  },
-  {
-    section: "settings",
-    category: "Internationalization",
-    subCategory: "Locales",
-    pluginName: "i18n",
-    displayName: "Update",
-    uid: "locale.update"
+    name: "Zarma (Niger) (dje-NE)"
   },
   {
-    section: "settings",
-    category: "Internationalization",
-    subCategory: "Locales",
-    pluginName: "i18n",
-    displayName: "Delete",
-    uid: "locale.delete"
+    code: "zu",
+    name: "Zulu (zu)"
+  },
+  {
+    code: "zu-ZA",
+    name: "Zulu (South Africa) (zu-ZA)"
   }
 ];
-const addLocalesPropertyIfNeeded = ({ value: action }) => {
-  const {
-    section,
-    options: { applyToProperties }
-  } = action;
-  if (section !== "contentTypes") {
-    return;
-  }
-  if (fp.isArray(applyToProperties) && applyToProperties.includes("locales")) {
-    return;
-  }
-  action.options.applyToProperties = fp.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 (permissions2) => {
-  const { actionProvider } = strapi.service("admin::permission");
-  const { find: findAllLocales } = getService("locales");
-  const allLocales = await findAllLocales();
-  const allLocalesCode = allLocales.map(fp.prop("code"));
-  return Promise.all(
-    permissions2.map(async (permission) => {
-      const { action, subject } = permission;
-      const appliesToLocalesProperty = await actionProvider.appliesToProperty(
-        "locales",
-        action,
-        subject
+const getInitLocale = () => {
+  const envLocaleCode = process.env.STRAPI_PLUGIN_I18N_INIT_LOCALE_CODE;
+  if (envLocaleCode) {
+    const matchingLocale = isoLocales.find(({ code }) => code === envLocaleCode);
+    if (!matchingLocale) {
+      throw new Error(
+        "Unknown locale code provided in the environment variable STRAPI_PLUGIN_I18N_INIT_LOCALE_CODE"
       );
-      if (!appliesToLocalesProperty) {
-        return permission;
-      }
-      const oldPermissionProperties = fp.getOr({}, "properties", permission);
-      return { ...permission, properties: { ...oldPermissionProperties, locales: allLocalesCode } };
-    })
-  );
-};
-const syncSuperAdminPermissionsWithLocales = async () => {
-  const roleService = strapi.service("admin::role");
-  const permissionService = strapi.service("admin::permission");
-  const superAdminRole = await roleService.getSuperAdmin();
-  if (!superAdminRole) {
-    return;
-  }
-  const superAdminPermissions = await permissionService.findMany({
-    where: {
-      role: {
-        id: superAdminRole.id
-      }
-    }
-  });
-  const newSuperAdminPermissions = await addAllLocalesToPermissions(superAdminPermissions);
-  await roleService.assignPermissions(superAdminRole.id, newSuperAdminPermissions);
-};
-const registerI18nActions = async () => {
-  const { actionProvider } = strapi.service("admin::permission");
-  await actionProvider.registerMany(actions);
-};
-const registerI18nActionsHooks = () => {
-  const { actionProvider } = strapi.service("admin::permission");
-  const { hooks } = strapi.service("admin::role");
-  actionProvider.hooks.appliesPropertyToSubject.register(shouldApplyLocalesPropertyToSubject);
-  hooks.willResetSuperAdminPermissions.register(addAllLocalesToPermissions);
-};
-const updateActionsProperties = () => {
-  const { actionProvider } = strapi.service("admin::permission");
-  actionProvider.hooks.willRegister.register(addLocalesPropertyIfNeeded);
-  actionProvider.values().forEach((action) => addLocalesPropertyIfNeeded({ value: action }));
-};
-const i18nActionsService = {
-  actions,
-  registerI18nActions,
-  registerI18nActionsHooks,
-  updateActionsProperties,
-  syncSuperAdminPermissionsWithLocales
-};
-const localesPropertyHandler = async ({ action, section }) => {
-  const { actionProvider } = strapi.service("admin::permission");
-  const locales2 = await getService("locales").find();
-  if (fp.isEmpty(locales2)) {
-    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: locales2.map(({ name, code }) => ({ label: name || code, value: code }))
-      });
-    }
-  }
-};
-const registerLocalesPropertyHandler = () => {
-  const { sectionsBuilder } = strapi.service("admin::permission");
-  sectionsBuilder.addHandler("singleTypes", localesPropertyHandler);
-  sectionsBuilder.addHandler("collectionTypes", localesPropertyHandler);
-};
-const sectionsBuilderService = {
-  localesPropertyHandler,
-  registerLocalesPropertyHandler
-};
-const willRegisterPermission = (context) => {
-  const { permission, condition, user } = context;
-  const { subject, properties } = permission;
-  const isSuperAdmin = strapi.service("admin::role").hasSuperAdminRole(user);
-  if (isSuperAdmin) {
-    return;
-  }
-  const { locales: locales2 } = properties || {};
-  const { isLocalizedContentType: isLocalizedContentType2 } = getService("content-types");
-  if (!subject) {
-    return;
-  }
-  const ct = strapi.contentTypes[subject];
-  if (!isLocalizedContentType2(ct)) {
-    return;
-  }
-  if (locales2 === null) {
-    return;
-  }
-  condition.and({
-    locale: {
-      $in: locales2 || []
     }
-  });
-};
-const registerI18nPermissionsHandlers = () => {
-  const { engine } = strapi.service("admin::permission");
-  engine.hooks["before-register.permission"].register(willRegisterPermission);
-};
-const engineService = {
-  willRegisterPermission,
-  registerI18nPermissionsHandlers
-};
-const permissions = () => ({
-  actions: i18nActionsService,
-  sectionsBuilder: sectionsBuilderService,
-  engine: engineService
-});
-const sendDidInitializeEvent = async () => {
-  const { isLocalizedContentType: isLocalizedContentType2 } = getService("content-types");
-  const numberOfContentTypes = fp.reduce(
-    (sum, contentType) => isLocalizedContentType2(contentType) ? sum + 1 : sum,
-    0
-  )(strapi.contentTypes);
-  await strapi.telemetry.send("didInitializeI18n", { groupProperties: { numberOfContentTypes } });
-};
-const sendDidUpdateI18nLocalesEvent = async () => {
-  const numberOfLocales = await getService("locales").count();
-  await strapi.telemetry.send("didUpdateI18nLocales", {
-    groupProperties: { numberOfLocales }
-  });
-};
-const metrics = () => ({
-  sendDidInitializeEvent,
-  sendDidUpdateI18nLocalesEvent
-});
-const syncNonLocalizedAttributes = async (sourceEntry, model) => {
-  const { copyNonLocalizedAttributes: copyNonLocalizedAttributes2 } = getService("content-types");
-  const nonLocalizedAttributes = copyNonLocalizedAttributes2(model, sourceEntry);
-  if (fp.isEmpty(nonLocalizedAttributes)) {
-    return;
+    return { ...matchingLocale };
   }
-  const uid = model.uid;
-  const documentId = sourceEntry.documentId;
-  const locale2 = sourceEntry.locale;
-  const status = sourceEntry?.publishedAt ? "published" : "draft";
-  const localeEntriesToUpdate = await strapi.db.query(uid).findMany({
-    where: {
-      documentId,
-      publishedAt: status === "published" ? { $ne: null } : null,
-      locale: { $ne: locale2 }
-    },
-    select: ["locale", "id"]
-  });
-  const entryData = await strapi.documents(uid).omitComponentData(nonLocalizedAttributes);
-  await utils.async.map(localeEntriesToUpdate, async (entry) => {
-    const transformedData = await strapi.documents.utils.transformData(
-      fp.cloneDeep(nonLocalizedAttributes),
-      {
-        uid,
-        status,
-        locale: entry.locale,
-        allowMissingId: true
-      }
-    );
-    const componentData = await strapi.documents(uid).updateComponents(entry, transformedData);
-    await strapi.db.query(uid).update({
-      where: {
-        documentId,
-        publishedAt: status === "published" ? { $ne: null } : null,
-        locale: { $eq: entry.locale }
-      },
-      // The data we send to the update function is the entry data merged with
-      // the updated component data
-      data: Object.assign(fp.cloneDeep(entryData), componentData)
-    });
-  });
+  return {
+    code: "en",
+    name: "English (en)"
+  };
 };
-const localizations = () => ({
-  syncNonLocalizedAttributes
-});
+const DEFAULT_LOCALE = getInitLocale();
 const find = (params = {}) => strapi.db.query("plugin::i18n.locale").findMany({ where: params });
 const findById = (id) => strapi.db.query("plugin::i18n.locale").findOne({ where: { id } });
 const findByCode = (code) => strapi.db.query("plugin::i18n.locale").findOne({ where: { code } });
@@ -3066,91 +3035,6 @@ const getIsoLocales = () => isoLocales;
 const isoLocalesService = () => ({
   getIsoLocales
 });
-const LOCALE_QUERY_FILTER = "locale";
-const SINGLE_ENTRY_ACTIONS = ["findOne", "update", "delete"];
-const BULK_ACTIONS = ["delete"];
-const paramsContain = (key, params) => {
-  return fp.has(key, params.filters) || fp.isArray(params.filters) && params.filters.some((clause) => fp.has(key, clause)) || fp.isArray(fp.get("$and", params.filters)) && params.filters.$and.some((clause) => fp.has(key, clause));
-};
-const wrapParams = async (params = {}, ctx = {}) => {
-  const { action } = ctx;
-  if (fp.has(LOCALE_QUERY_FILTER, params)) {
-    if (params[LOCALE_QUERY_FILTER] === "all") {
-      return fp.omit(LOCALE_QUERY_FILTER, params);
-    }
-    return {
-      ...fp.omit(LOCALE_QUERY_FILTER, params),
-      filters: {
-        $and: [{ locale: params[LOCALE_QUERY_FILTER] }].concat(params.filters || [])
-      }
-    };
-  }
-  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: getDefaultLocale2 } = getService("locales");
-  return {
-    ...params,
-    filters: {
-      $and: [{ locale: await getDefaultLocale2() }].concat(params.filters || [])
-    }
-  };
-};
-const decorator = (service) => ({
-  /**
-   * Wraps result
-   * @param {object} result - result object of query
-   * @param {object} ctx - Query context
-   * @param {object} ctx.model - Model that is being used
-   */
-  async wrapResult(result = {}, ctx = {}) {
-    return service.wrapResult.call(this, result, ctx);
-  },
-  /**
-   * Wraps query options. In particular will add default locale to query params
-   * @param {object} params - Query options object (params, data, files, populate)
-   * @param {object} ctx - Query context
-   * @param {object} ctx.model - Model that is being used
-   */
-  async wrapParams(params = {}, ctx = {}) {
-    const wrappedParams = await service.wrapParams.call(this, params, ctx);
-    const model = strapi.getModel(ctx.uid);
-    const { isLocalizedContentType: isLocalizedContentType2 } = getService("content-types");
-    if (!isLocalizedContentType2(model)) {
-      return wrappedParams;
-    }
-    return wrapParams(wrappedParams, ctx);
-  },
-  /**
-   * Find an entry or several if fetching all locales
-   * @param {string} uid - Model uid
-   * @param {object} opts - Query options object (params, data, files, populate)
-   */
-  async findMany(uid, opts) {
-    const model = strapi.getModel(uid);
-    const { isLocalizedContentType: isLocalizedContentType2 } = getService("content-types");
-    if (!isLocalizedContentType2(model)) {
-      return service.findMany.call(this, uid, opts);
-    }
-    const { kind } = model;
-    if (kind === "singleType") {
-      if (opts[LOCALE_QUERY_FILTER] === "all") {
-        const wrappedParams = await this.wrapParams(opts, { uid, action: "findMany" });
-        const query = strapi.get("query-params").transform(uid, wrappedParams);
-        const entities = await strapi.db.query(uid).findMany(query);
-        return this.wrapResult(entities, { uid, action: "findMany" });
-      }
-      return service.findMany.call(this, uid, opts);
-    }
-    return service.findMany.call(this, uid, opts);
-  }
-});
-const entityServiceDecorator = () => ({
-  decorator,
-  wrapParams
-});
 const {
   isRelationalAttribute,
   getVisibleAttributes,
@@ -3275,13 +3159,33 @@ const contentTypes = () => ({
   fillNonLocalizedAttributes,
   getNestedPopulateOfNonLocalizedAttributes
 });
+const LOCALIZATION_FIELDS = ["locale", "localizations"];
+const sanitize = ({ strapi: strapi2 }) => {
+  const { isLocalizedContentType: isLocalizedContentType2 } = getService("content-types");
+  const sanitizeLocalizationFields = fp.curry(
+    (schema2, entity) => utils.traverseEntity(
+      ({ key, schema: schema22 }, { remove }) => {
+        const isLocalized = isLocalizedContentType2(schema22);
+        const isLocalizationField = LOCALIZATION_FIELDS.includes(key);
+        if (!isLocalized && isLocalizationField) {
+          remove(key);
+        }
+      },
+      { schema: schema2, getModel: strapi2.getModel.bind(strapi2) },
+      entity
+    )
+  );
+  return {
+    sanitizeLocalizationFields
+  };
+};
 const services = {
   permissions,
   metrics,
   localizations,
   locales,
+  sanitize,
   "iso-locales": isoLocalesService,
-  "entity-service-decorator": entityServiceDecorator,
   "content-types": contentTypes
 };
 const admin = {