@strapi/i18n 5.0.0-rc.22 → 5.0.0-rc.24

package/dist/server/index.js

@@ -195,6 +195,350 @@ 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) => {
+  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"
+    });
+    ___default.default.set(attributes2, "localizations", {
+      type: "relation",
+      relation: "oneToMany",
+      target: contentType.uid,
+      writable: false,
+      private: false,
+      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",
@@ -2586,439 +2930,42 @@ const isoLocales = [
   },
   {
     code: "yo-NG",
-    name: "Yoruba (Nigeria) (yo-NG)"
-  },
-  {
-    code: "dje",
-    name: "Zarma (dje)"
-  },
-  {
-    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"
-    });
-    ___default.default.set(attributes2, "localizations", {
-      type: "relation",
-      relation: "oneToMany",
-      target: contentType.uid,
-      writable: false,
-      private: false,
-      configurable: false,
-      visible: false,
-      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 = [
+    name: "Yoruba (Nigeria) (yo-NG)"
+  },
   {
-    section: "settings",
-    category: "Internationalization",
-    subCategory: "Locales",
-    pluginName: "i18n",
-    displayName: "Create",
-    uid: "locale.create"
+    code: "dje",
+    name: "Zarma (dje)"
   },
   {
-    section: "settings",
-    category: "Internationalization",
-    subCategory: "Locales",
-    pluginName: "i18n",
-    displayName: "Read",
-    uid: "locale.read",
-    aliases: [
-      { actionId: "plugin::content-manager.explorer.read", subjects: ["plugin::i18n.locale"] }
-    ]
+    code: "dje-NE",
+    name: "Zarma (Niger) (dje-NE)"
   },
   {
-    section: "settings",
-    category: "Internationalization",
-    subCategory: "Locales",
-    pluginName: "i18n",
-    displayName: "Update",
-    uid: "locale.update"
+    code: "zu",
+    name: "Zulu (zu)"
   },
   {
-    section: "settings",
-    category: "Internationalization",
-    subCategory: "Locales",
-    pluginName: "i18n",
-    displayName: "Delete",
-    uid: "locale.delete"
+    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 } });