@strapi/i18n 5.0.0-rc.8 → 5.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (49) hide show
  1. package/dist/_chunks/{SettingsPage-CsGvujny.mjs → SettingsPage-DbRFoF_H.mjs} +8 -8
  2. package/dist/_chunks/SettingsPage-DbRFoF_H.mjs.map +1 -0
  3. package/dist/_chunks/{SettingsPage-DA9haizZ.js → SettingsPage-uGJv15wR.js} +8 -8
  4. package/dist/_chunks/SettingsPage-uGJv15wR.js.map +1 -0
  5. package/dist/_chunks/{en-CM6Pjfyv.mjs → en-BYRZFDBV.mjs} +9 -2
  6. package/dist/_chunks/en-BYRZFDBV.mjs.map +1 -0
  7. package/dist/_chunks/{en-BsOU9o5z.js → en-Dk9At9_Z.js} +9 -2
  8. package/dist/_chunks/en-Dk9At9_Z.js.map +1 -0
  9. package/dist/_chunks/{index-CCZJF_EJ.mjs → index-7_EUScSl.mjs} +391 -144
  10. package/dist/_chunks/index-7_EUScSl.mjs.map +1 -0
  11. package/dist/_chunks/{index-DIzVXZoE.js → index-BGtXLYX-.js} +384 -137
  12. package/dist/_chunks/index-BGtXLYX-.js.map +1 -0
  13. package/dist/admin/index.js +1 -1
  14. package/dist/admin/index.mjs +1 -1
  15. package/dist/admin/src/components/BulkLocaleActionModal.d.ts +2 -1
  16. package/dist/admin/src/components/CMHeaderActions.d.ts +29 -3
  17. package/dist/admin/src/components/CreateLocale.d.ts +6 -6
  18. package/dist/admin/src/utils/clean.d.ts +4 -0
  19. package/dist/server/index.js +397 -487
  20. package/dist/server/index.js.map +1 -1
  21. package/dist/server/index.mjs +398 -488
  22. package/dist/server/index.mjs.map +1 -1
  23. package/dist/server/src/bootstrap.d.ts +1 -4
  24. package/dist/server/src/bootstrap.d.ts.map +1 -1
  25. package/dist/server/src/index.d.ts +15 -13
  26. package/dist/server/src/index.d.ts.map +1 -1
  27. package/dist/server/src/register.d.ts.map +1 -1
  28. package/dist/server/src/services/index.d.ts +14 -10
  29. package/dist/server/src/services/index.d.ts.map +1 -1
  30. package/dist/server/src/services/permissions/actions.d.ts +14 -2
  31. package/dist/server/src/services/permissions/actions.d.ts.map +1 -1
  32. package/dist/server/src/services/permissions.d.ts +14 -2
  33. package/dist/server/src/services/permissions.d.ts.map +1 -1
  34. package/dist/server/src/utils/index.d.ts +0 -2
  35. package/dist/server/src/utils/index.d.ts.map +1 -1
  36. package/package.json +9 -9
  37. package/dist/_chunks/SettingsPage-CsGvujny.mjs.map +0 -1
  38. package/dist/_chunks/SettingsPage-DA9haizZ.js.map +0 -1
  39. package/dist/_chunks/en-BsOU9o5z.js.map +0 -1
  40. package/dist/_chunks/en-CM6Pjfyv.mjs.map +0 -1
  41. package/dist/_chunks/index-CCZJF_EJ.mjs.map +0 -1
  42. package/dist/_chunks/index-DIzVXZoE.js.map +0 -1
  43. package/dist/server/src/migrations/content-type/disable/index.d.ts +0 -3
  44. package/dist/server/src/migrations/content-type/disable/index.d.ts.map +0 -1
  45. package/dist/server/src/migrations/content-type/enable/index.d.ts +0 -3
  46. package/dist/server/src/migrations/content-type/enable/index.d.ts.map +0 -1
  47. package/dist/server/src/services/entity-service-decorator.d.ts +0 -29
  48. package/dist/server/src/services/entity-service-decorator.d.ts.map +0 -1
  49. package/strapi-server.js +0 -3
@@ -51,7 +51,7 @@ const registerModelsHooks = () => {
51
51
  const attributesToPopulate = getNestedPopulateOfNonLocalizedAttributes2(schema2.uid);
52
52
  const result = await next();
53
53
  let resultID;
54
- if (Array.isArray(result?.entries)) {
54
+ if (Array.isArray(result?.entries) && result.entries[0]?.id) {
55
55
  resultID = result.entries[0].id;
56
56
  } else if (result?.id) {
57
57
  resultID = result.id;
@@ -65,12 +65,10 @@ const registerModelsHooks = () => {
65
65
  return result;
66
66
  });
67
67
  };
68
- const bootstrap = async ({ strapi: strapi2 }) => {
68
+ const bootstrap = async () => {
69
69
  const { sendDidInitializeEvent: sendDidInitializeEvent2 } = getService("metrics");
70
- const { decorator: decorator2 } = getService("entity-service-decorator");
71
70
  const { initDefaultLocale: initDefaultLocale2 } = getService("locales");
72
71
  const { sectionsBuilder, actions: actions2, engine } = getService("permissions");
73
- strapi2.entityService.decorate(decorator2);
74
72
  await initDefaultLocale2();
75
73
  sectionsBuilder.registerLocalesPropertyHandler();
76
74
  await actions2.registerI18nActions();
@@ -197,6 +195,350 @@ const getI18nLocaleArgPlugin = ({ nexus, typeRegistry }) => {
197
195
  }
198
196
  });
199
197
  };
198
+ const register = ({ strapi: strapi2 }) => {
199
+ extendContentTypes(strapi2);
200
+ addContentManagerLocaleMiddleware(strapi2);
201
+ };
202
+ const addContentManagerLocaleMiddleware = (strapi2) => {
203
+ strapi2.server.router.use("/content-manager/collection-types/:model", (ctx, next) => {
204
+ if (ctx.method === "POST" || ctx.method === "PUT") {
205
+ return validateLocaleCreation(ctx, next);
206
+ }
207
+ return next();
208
+ });
209
+ strapi2.server.router.use("/content-manager/single-types/:model", (ctx, next) => {
210
+ if (ctx.method === "POST" || ctx.method === "PUT") {
211
+ return validateLocaleCreation(ctx, next);
212
+ }
213
+ return next();
214
+ });
215
+ };
216
+ const extendContentTypes = (strapi2) => {
217
+ Object.values(strapi2.contentTypes).forEach((contentType) => {
218
+ const { attributes: attributes2 } = contentType;
219
+ ___default.default.set(attributes2, "locale", {
220
+ writable: true,
221
+ private: false,
222
+ configurable: false,
223
+ visible: false,
224
+ type: "string"
225
+ });
226
+ ___default.default.set(attributes2, "localizations", {
227
+ type: "relation",
228
+ relation: "oneToMany",
229
+ target: contentType.uid,
230
+ writable: false,
231
+ private: false,
232
+ configurable: false,
233
+ visible: false,
234
+ unstable_virtual: true,
235
+ joinColumn: {
236
+ name: "document_id",
237
+ referencedColumn: "document_id",
238
+ referencedTable: strapi2.db.metadata.identifiers.getTableName(contentType.collectionName),
239
+ // ensure the population will not include the results we already loaded
240
+ on({ results }) {
241
+ return {
242
+ id: {
243
+ $notIn: results.map((r) => r.id)
244
+ }
245
+ };
246
+ }
247
+ }
248
+ });
249
+ });
250
+ if (strapi2.plugin("graphql")) {
251
+ graphqlProvider({ strapi: strapi2 }).register();
252
+ }
253
+ };
254
+ const info = {
255
+ singularName: "locale",
256
+ pluralName: "locales",
257
+ collectionName: "locales",
258
+ displayName: "Locale",
259
+ description: ""
260
+ };
261
+ const options = {};
262
+ const pluginOptions = {
263
+ "content-manager": {
264
+ visible: false
265
+ },
266
+ "content-type-builder": {
267
+ visible: false
268
+ }
269
+ };
270
+ const attributes = {
271
+ name: {
272
+ type: "string",
273
+ min: 1,
274
+ max: 50,
275
+ configurable: false
276
+ },
277
+ code: {
278
+ type: "string",
279
+ unique: true,
280
+ configurable: false
281
+ }
282
+ };
283
+ const schema = {
284
+ info,
285
+ options,
286
+ pluginOptions,
287
+ attributes
288
+ };
289
+ const locale = {
290
+ schema
291
+ };
292
+ const contentTypes$1 = {
293
+ locale
294
+ };
295
+ const actions = [
296
+ {
297
+ section: "settings",
298
+ category: "Internationalization",
299
+ subCategory: "Locales",
300
+ pluginName: "i18n",
301
+ displayName: "Create",
302
+ uid: "locale.create"
303
+ },
304
+ {
305
+ section: "settings",
306
+ category: "Internationalization",
307
+ subCategory: "Locales",
308
+ pluginName: "i18n",
309
+ displayName: "Read",
310
+ uid: "locale.read",
311
+ aliases: [
312
+ { actionId: "plugin::content-manager.explorer.read", subjects: ["plugin::i18n.locale"] }
313
+ ]
314
+ },
315
+ {
316
+ section: "settings",
317
+ category: "Internationalization",
318
+ subCategory: "Locales",
319
+ pluginName: "i18n",
320
+ displayName: "Update",
321
+ uid: "locale.update"
322
+ },
323
+ {
324
+ section: "settings",
325
+ category: "Internationalization",
326
+ subCategory: "Locales",
327
+ pluginName: "i18n",
328
+ displayName: "Delete",
329
+ uid: "locale.delete"
330
+ }
331
+ ];
332
+ const addLocalesPropertyIfNeeded = ({ value: action }) => {
333
+ const {
334
+ section,
335
+ options: { applyToProperties }
336
+ } = action;
337
+ if (section !== "contentTypes") {
338
+ return;
339
+ }
340
+ if (fp.isArray(applyToProperties) && applyToProperties.includes("locales")) {
341
+ return;
342
+ }
343
+ action.options.applyToProperties = fp.isArray(applyToProperties) ? applyToProperties.concat("locales") : ["locales"];
344
+ };
345
+ const shouldApplyLocalesPropertyToSubject = ({ property, subject }) => {
346
+ if (property === "locales") {
347
+ const model = strapi.getModel(subject);
348
+ return getService("content-types").isLocalizedContentType(model);
349
+ }
350
+ return true;
351
+ };
352
+ const addAllLocalesToPermissions = async (permissions2) => {
353
+ const { actionProvider } = strapi.service("admin::permission");
354
+ const { find: findAllLocales } = getService("locales");
355
+ const allLocales = await findAllLocales();
356
+ const allLocalesCode = allLocales.map(fp.prop("code"));
357
+ return Promise.all(
358
+ permissions2.map(async (permission) => {
359
+ const { action, subject } = permission;
360
+ const appliesToLocalesProperty = await actionProvider.appliesToProperty(
361
+ "locales",
362
+ action,
363
+ subject
364
+ );
365
+ if (!appliesToLocalesProperty) {
366
+ return permission;
367
+ }
368
+ const oldPermissionProperties = fp.getOr({}, "properties", permission);
369
+ return { ...permission, properties: { ...oldPermissionProperties, locales: allLocalesCode } };
370
+ })
371
+ );
372
+ };
373
+ const syncSuperAdminPermissionsWithLocales = async () => {
374
+ const roleService = strapi.service("admin::role");
375
+ const permissionService = strapi.service("admin::permission");
376
+ const superAdminRole = await roleService.getSuperAdmin();
377
+ if (!superAdminRole) {
378
+ return;
379
+ }
380
+ const superAdminPermissions = await permissionService.findMany({
381
+ where: {
382
+ role: {
383
+ id: superAdminRole.id
384
+ }
385
+ }
386
+ });
387
+ const newSuperAdminPermissions = await addAllLocalesToPermissions(superAdminPermissions);
388
+ await roleService.assignPermissions(superAdminRole.id, newSuperAdminPermissions);
389
+ };
390
+ const registerI18nActions = async () => {
391
+ const { actionProvider } = strapi.service("admin::permission");
392
+ await actionProvider.registerMany(actions);
393
+ };
394
+ const registerI18nActionsHooks = () => {
395
+ const { actionProvider } = strapi.service("admin::permission");
396
+ const { hooks } = strapi.service("admin::role");
397
+ actionProvider.hooks.appliesPropertyToSubject.register(shouldApplyLocalesPropertyToSubject);
398
+ hooks.willResetSuperAdminPermissions.register(addAllLocalesToPermissions);
399
+ };
400
+ const updateActionsProperties = () => {
401
+ const { actionProvider } = strapi.service("admin::permission");
402
+ actionProvider.hooks.willRegister.register(addLocalesPropertyIfNeeded);
403
+ actionProvider.values().forEach((action) => addLocalesPropertyIfNeeded({ value: action }));
404
+ };
405
+ const i18nActionsService = {
406
+ actions,
407
+ registerI18nActions,
408
+ registerI18nActionsHooks,
409
+ updateActionsProperties,
410
+ syncSuperAdminPermissionsWithLocales
411
+ };
412
+ const localesPropertyHandler = async ({ action, section }) => {
413
+ const { actionProvider } = strapi.service("admin::permission");
414
+ const locales2 = await getService("locales").find();
415
+ if (fp.isEmpty(locales2)) {
416
+ return;
417
+ }
418
+ for (const subject of section.subjects) {
419
+ const applies = await actionProvider.appliesToProperty("locales", action.actionId, subject.uid);
420
+ const hasLocalesProperty = subject.properties.find(
421
+ (property) => property.value === "locales"
422
+ );
423
+ if (applies && !hasLocalesProperty) {
424
+ subject.properties.push({
425
+ label: "Locales",
426
+ value: "locales",
427
+ children: locales2.map(({ name, code }) => ({ label: name || code, value: code }))
428
+ });
429
+ }
430
+ }
431
+ };
432
+ const registerLocalesPropertyHandler = () => {
433
+ const { sectionsBuilder } = strapi.service("admin::permission");
434
+ sectionsBuilder.addHandler("singleTypes", localesPropertyHandler);
435
+ sectionsBuilder.addHandler("collectionTypes", localesPropertyHandler);
436
+ };
437
+ const sectionsBuilderService = {
438
+ localesPropertyHandler,
439
+ registerLocalesPropertyHandler
440
+ };
441
+ const willRegisterPermission = (context) => {
442
+ const { permission, condition, user } = context;
443
+ const { subject, properties } = permission;
444
+ const isSuperAdmin = strapi.service("admin::role").hasSuperAdminRole(user);
445
+ if (isSuperAdmin) {
446
+ return;
447
+ }
448
+ const { locales: locales2 } = properties || {};
449
+ const { isLocalizedContentType: isLocalizedContentType2 } = getService("content-types");
450
+ if (!subject) {
451
+ return;
452
+ }
453
+ const ct = strapi.contentTypes[subject];
454
+ if (!isLocalizedContentType2(ct)) {
455
+ return;
456
+ }
457
+ if (locales2 === null) {
458
+ return;
459
+ }
460
+ condition.and({
461
+ locale: {
462
+ $in: locales2 || []
463
+ }
464
+ });
465
+ };
466
+ const registerI18nPermissionsHandlers = () => {
467
+ const { engine } = strapi.service("admin::permission");
468
+ engine.hooks["before-register.permission"].register(willRegisterPermission);
469
+ };
470
+ const engineService = {
471
+ willRegisterPermission,
472
+ registerI18nPermissionsHandlers
473
+ };
474
+ const permissions = () => ({
475
+ actions: i18nActionsService,
476
+ sectionsBuilder: sectionsBuilderService,
477
+ engine: engineService
478
+ });
479
+ const sendDidInitializeEvent = async () => {
480
+ const { isLocalizedContentType: isLocalizedContentType2 } = getService("content-types");
481
+ const numberOfContentTypes = fp.reduce(
482
+ (sum, contentType) => isLocalizedContentType2(contentType) ? sum + 1 : sum,
483
+ 0
484
+ )(strapi.contentTypes);
485
+ await strapi.telemetry.send("didInitializeI18n", { groupProperties: { numberOfContentTypes } });
486
+ };
487
+ const sendDidUpdateI18nLocalesEvent = async () => {
488
+ const numberOfLocales = await getService("locales").count();
489
+ await strapi.telemetry.send("didUpdateI18nLocales", {
490
+ groupProperties: { numberOfLocales }
491
+ });
492
+ };
493
+ const metrics = () => ({
494
+ sendDidInitializeEvent,
495
+ sendDidUpdateI18nLocalesEvent
496
+ });
497
+ const syncNonLocalizedAttributes = async (sourceEntry, model) => {
498
+ const { copyNonLocalizedAttributes: copyNonLocalizedAttributes2 } = getService("content-types");
499
+ const nonLocalizedAttributes = copyNonLocalizedAttributes2(model, sourceEntry);
500
+ if (fp.isEmpty(nonLocalizedAttributes)) {
501
+ return;
502
+ }
503
+ const uid = model.uid;
504
+ const documentId = sourceEntry.documentId;
505
+ const locale2 = sourceEntry.locale;
506
+ const status = sourceEntry?.publishedAt ? "published" : "draft";
507
+ const localeEntriesToUpdate = await strapi.db.query(uid).findMany({
508
+ where: {
509
+ documentId,
510
+ publishedAt: status === "published" ? { $ne: null } : null,
511
+ locale: { $ne: locale2 }
512
+ },
513
+ select: ["locale", "id"]
514
+ });
515
+ const entryData = await strapi.documents(uid).omitComponentData(nonLocalizedAttributes);
516
+ await utils.async.map(localeEntriesToUpdate, async (entry) => {
517
+ const transformedData = await strapi.documents.utils.transformData(
518
+ fp.cloneDeep(nonLocalizedAttributes),
519
+ {
520
+ uid,
521
+ status,
522
+ locale: entry.locale,
523
+ allowMissingId: true
524
+ }
525
+ );
526
+ const componentData = await strapi.documents(uid).updateComponents(entry, transformedData);
527
+ await strapi.db.query(uid).update({
528
+ where: {
529
+ documentId,
530
+ publishedAt: status === "published" ? { $ne: null } : null,
531
+ locale: { $eq: entry.locale }
532
+ },
533
+ // The data we send to the update function is the entry data merged with
534
+ // the updated component data
535
+ data: Object.assign(fp.cloneDeep(entryData), componentData)
536
+ });
537
+ });
538
+ };
539
+ const localizations = () => ({
540
+ syncNonLocalizedAttributes
541
+ });
200
542
  const isoLocales = [
201
543
  {
202
544
  code: "af",
@@ -2568,408 +2910,62 @@ const isoLocales = [
2568
2910
  },
2569
2911
  {
2570
2912
  code: "cy",
2571
- name: "Welsh (cy)"
2572
- },
2573
- {
2574
- code: "cy-GB",
2575
- name: "Welsh (United Kingdom) (cy-GB)"
2576
- },
2577
- {
2578
- code: "yav",
2579
- name: "Yangben (yav)"
2580
- },
2581
- {
2582
- code: "yav-CM",
2583
- name: "Yangben (Cameroon) (yav-CM)"
2584
- },
2585
- {
2586
- code: "yo",
2587
- name: "Yoruba (yo)"
2588
- },
2589
- {
2590
- code: "yo-NG",
2591
- name: "Yoruba (Nigeria) (yo-NG)"
2592
- },
2593
- {
2594
- code: "dje",
2595
- name: "Zarma (dje)"
2596
- },
2597
- {
2598
- code: "dje-NE",
2599
- name: "Zarma (Niger) (dje-NE)"
2600
- },
2601
- {
2602
- code: "zu",
2603
- name: "Zulu (zu)"
2604
- },
2605
- {
2606
- code: "zu-ZA",
2607
- name: "Zulu (South Africa) (zu-ZA)"
2608
- }
2609
- ];
2610
- const getInitLocale = () => {
2611
- const envLocaleCode = process.env.STRAPI_PLUGIN_I18N_INIT_LOCALE_CODE;
2612
- if (envLocaleCode) {
2613
- const matchingLocale = isoLocales.find(({ code }) => code === envLocaleCode);
2614
- if (!matchingLocale) {
2615
- throw new Error(
2616
- "Unknown locale code provided in the environment variable STRAPI_PLUGIN_I18N_INIT_LOCALE_CODE"
2617
- );
2618
- }
2619
- return { ...matchingLocale };
2620
- }
2621
- return {
2622
- code: "en",
2623
- name: "English (en)"
2624
- };
2625
- };
2626
- const DEFAULT_LOCALE = getInitLocale();
2627
- const enableContentType = async ({ oldContentTypes, contentTypes: contentTypes2 }) => {
2628
- const { isLocalizedContentType: isLocalizedContentType2 } = getService("content-types");
2629
- const { getDefaultLocale: getDefaultLocale2 } = getService("locales");
2630
- if (!oldContentTypes) {
2631
- return;
2632
- }
2633
- for (const uid in contentTypes2) {
2634
- if (!oldContentTypes[uid]) {
2635
- continue;
2636
- }
2637
- const oldContentType = oldContentTypes[uid];
2638
- const contentType = contentTypes2[uid];
2639
- if (!isLocalizedContentType2(oldContentType) && isLocalizedContentType2(contentType)) {
2640
- const defaultLocale = await getDefaultLocale2() || DEFAULT_LOCALE.code;
2641
- await strapi.db.query(uid).updateMany({
2642
- where: { locale: null },
2643
- data: { locale: defaultLocale }
2644
- });
2645
- }
2646
- }
2647
- };
2648
- const disableContentType = async ({ oldContentTypes, contentTypes: contentTypes2 }) => {
2649
- const { isLocalizedContentType: isLocalizedContentType2 } = getService("content-types");
2650
- const { getDefaultLocale: getDefaultLocale2 } = getService("locales");
2651
- if (!oldContentTypes) {
2652
- return;
2653
- }
2654
- for (const uid in contentTypes2) {
2655
- if (!oldContentTypes[uid]) {
2656
- continue;
2657
- }
2658
- const oldContentType = oldContentTypes[uid];
2659
- const contentType = contentTypes2[uid];
2660
- if (isLocalizedContentType2(oldContentType) && !isLocalizedContentType2(contentType)) {
2661
- const defaultLocale = await getDefaultLocale2() || DEFAULT_LOCALE.code;
2662
- await Promise.all([
2663
- // Delete all entities that are not in the default locale
2664
- strapi.db.query(uid).deleteMany({
2665
- where: { locale: { $ne: defaultLocale } }
2666
- }),
2667
- // Set locale to null for the rest
2668
- strapi.db.query(uid).updateMany({
2669
- where: { locale: { $eq: defaultLocale } },
2670
- data: { locale: null }
2671
- })
2672
- ]);
2673
- }
2674
- }
2675
- };
2676
- const register = ({ strapi: strapi2 }) => {
2677
- extendContentTypes(strapi2);
2678
- addContentManagerLocaleMiddleware(strapi2);
2679
- addContentTypeSyncHooks(strapi2);
2680
- };
2681
- const addContentManagerLocaleMiddleware = (strapi2) => {
2682
- strapi2.server.router.use("/content-manager/collection-types/:model", (ctx, next) => {
2683
- if (ctx.method === "POST" || ctx.method === "PUT") {
2684
- return validateLocaleCreation(ctx, next);
2685
- }
2686
- return next();
2687
- });
2688
- strapi2.server.router.use("/content-manager/single-types/:model", (ctx, next) => {
2689
- if (ctx.method === "POST" || ctx.method === "PUT") {
2690
- return validateLocaleCreation(ctx, next);
2691
- }
2692
- return next();
2693
- });
2694
- };
2695
- const addContentTypeSyncHooks = (strapi2) => {
2696
- strapi2.hook("strapi::content-types.beforeSync").register(disableContentType);
2697
- strapi2.hook("strapi::content-types.afterSync").register(enableContentType);
2698
- };
2699
- const extendContentTypes = (strapi2) => {
2700
- Object.values(strapi2.contentTypes).forEach((contentType) => {
2701
- const { attributes: attributes2 } = contentType;
2702
- ___default.default.set(attributes2, "locale", {
2703
- writable: true,
2704
- private: false,
2705
- configurable: false,
2706
- visible: false,
2707
- type: "string"
2708
- });
2709
- });
2710
- if (strapi2.plugin("graphql")) {
2711
- graphqlProvider({ strapi: strapi2 }).register();
2712
- }
2713
- };
2714
- const info = {
2715
- singularName: "locale",
2716
- pluralName: "locales",
2717
- collectionName: "locales",
2718
- displayName: "Locale",
2719
- description: ""
2720
- };
2721
- const options = {};
2722
- const pluginOptions = {
2723
- "content-manager": {
2724
- visible: false
2725
- },
2726
- "content-type-builder": {
2727
- visible: false
2728
- }
2729
- };
2730
- const attributes = {
2731
- name: {
2732
- type: "string",
2733
- min: 1,
2734
- max: 50,
2735
- configurable: false
2736
- },
2737
- code: {
2738
- type: "string",
2739
- unique: true,
2740
- configurable: false
2741
- }
2742
- };
2743
- const schema = {
2744
- info,
2745
- options,
2746
- pluginOptions,
2747
- attributes
2748
- };
2749
- const locale = {
2750
- schema
2751
- };
2752
- const contentTypes$1 = {
2753
- locale
2754
- };
2755
- const actions = ["create", "read", "update", "delete"].map((uid) => ({
2756
- section: "settings",
2757
- category: "Internationalization",
2758
- subCategory: "Locales",
2759
- pluginName: "i18n",
2760
- displayName: fp.capitalize(uid),
2761
- uid: `locale.${uid}`
2762
- }));
2763
- const addLocalesPropertyIfNeeded = ({ value: action }) => {
2764
- const {
2765
- section,
2766
- options: { applyToProperties }
2767
- } = action;
2768
- if (section !== "contentTypes") {
2769
- return;
2770
- }
2771
- if (fp.isArray(applyToProperties) && applyToProperties.includes("locales")) {
2772
- return;
2773
- }
2774
- action.options.applyToProperties = fp.isArray(applyToProperties) ? applyToProperties.concat("locales") : ["locales"];
2775
- };
2776
- const shouldApplyLocalesPropertyToSubject = ({ property, subject }) => {
2777
- if (property === "locales") {
2778
- const model = strapi.getModel(subject);
2779
- return getService("content-types").isLocalizedContentType(model);
2913
+ name: "Welsh (cy)"
2914
+ },
2915
+ {
2916
+ code: "cy-GB",
2917
+ name: "Welsh (United Kingdom) (cy-GB)"
2918
+ },
2919
+ {
2920
+ code: "yav",
2921
+ name: "Yangben (yav)"
2922
+ },
2923
+ {
2924
+ code: "yav-CM",
2925
+ name: "Yangben (Cameroon) (yav-CM)"
2926
+ },
2927
+ {
2928
+ code: "yo",
2929
+ name: "Yoruba (yo)"
2930
+ },
2931
+ {
2932
+ code: "yo-NG",
2933
+ name: "Yoruba (Nigeria) (yo-NG)"
2934
+ },
2935
+ {
2936
+ code: "dje",
2937
+ name: "Zarma (dje)"
2938
+ },
2939
+ {
2940
+ code: "dje-NE",
2941
+ name: "Zarma (Niger) (dje-NE)"
2942
+ },
2943
+ {
2944
+ code: "zu",
2945
+ name: "Zulu (zu)"
2946
+ },
2947
+ {
2948
+ code: "zu-ZA",
2949
+ name: "Zulu (South Africa) (zu-ZA)"
2780
2950
  }
2781
- return true;
2782
- };
2783
- const addAllLocalesToPermissions = async (permissions2) => {
2784
- const { actionProvider } = strapi.service("admin::permission");
2785
- const { find: findAllLocales } = getService("locales");
2786
- const allLocales = await findAllLocales();
2787
- const allLocalesCode = allLocales.map(fp.prop("code"));
2788
- return Promise.all(
2789
- permissions2.map(async (permission) => {
2790
- const { action, subject } = permission;
2791
- const appliesToLocalesProperty = await actionProvider.appliesToProperty(
2792
- "locales",
2793
- action,
2794
- subject
2951
+ ];
2952
+ const getInitLocale = () => {
2953
+ const envLocaleCode = process.env.STRAPI_PLUGIN_I18N_INIT_LOCALE_CODE;
2954
+ if (envLocaleCode) {
2955
+ const matchingLocale = isoLocales.find(({ code }) => code === envLocaleCode);
2956
+ if (!matchingLocale) {
2957
+ throw new Error(
2958
+ "Unknown locale code provided in the environment variable STRAPI_PLUGIN_I18N_INIT_LOCALE_CODE"
2795
2959
  );
2796
- if (!appliesToLocalesProperty) {
2797
- return permission;
2798
- }
2799
- const oldPermissionProperties = fp.getOr({}, "properties", permission);
2800
- return { ...permission, properties: { ...oldPermissionProperties, locales: allLocalesCode } };
2801
- })
2802
- );
2803
- };
2804
- const syncSuperAdminPermissionsWithLocales = async () => {
2805
- const roleService = strapi.service("admin::role");
2806
- const permissionService = strapi.service("admin::permission");
2807
- const superAdminRole = await roleService.getSuperAdmin();
2808
- if (!superAdminRole) {
2809
- return;
2810
- }
2811
- const superAdminPermissions = await permissionService.findMany({
2812
- where: {
2813
- role: {
2814
- id: superAdminRole.id
2815
- }
2816
- }
2817
- });
2818
- const newSuperAdminPermissions = await addAllLocalesToPermissions(superAdminPermissions);
2819
- await roleService.assignPermissions(superAdminRole.id, newSuperAdminPermissions);
2820
- };
2821
- const registerI18nActions = async () => {
2822
- const { actionProvider } = strapi.service("admin::permission");
2823
- await actionProvider.registerMany(actions);
2824
- };
2825
- const registerI18nActionsHooks = () => {
2826
- const { actionProvider } = strapi.service("admin::permission");
2827
- const { hooks } = strapi.service("admin::role");
2828
- actionProvider.hooks.appliesPropertyToSubject.register(shouldApplyLocalesPropertyToSubject);
2829
- hooks.willResetSuperAdminPermissions.register(addAllLocalesToPermissions);
2830
- };
2831
- const updateActionsProperties = () => {
2832
- const { actionProvider } = strapi.service("admin::permission");
2833
- actionProvider.hooks.willRegister.register(addLocalesPropertyIfNeeded);
2834
- actionProvider.values().forEach((action) => addLocalesPropertyIfNeeded({ value: action }));
2835
- };
2836
- const i18nActionsService = {
2837
- actions,
2838
- registerI18nActions,
2839
- registerI18nActionsHooks,
2840
- updateActionsProperties,
2841
- syncSuperAdminPermissionsWithLocales
2842
- };
2843
- const localesPropertyHandler = async ({ action, section }) => {
2844
- const { actionProvider } = strapi.service("admin::permission");
2845
- const locales2 = await getService("locales").find();
2846
- if (fp.isEmpty(locales2)) {
2847
- return;
2848
- }
2849
- for (const subject of section.subjects) {
2850
- const applies = await actionProvider.appliesToProperty("locales", action.actionId, subject.uid);
2851
- const hasLocalesProperty = subject.properties.find(
2852
- (property) => property.value === "locales"
2853
- );
2854
- if (applies && !hasLocalesProperty) {
2855
- subject.properties.push({
2856
- label: "Locales",
2857
- value: "locales",
2858
- children: locales2.map(({ name, code }) => ({ label: name || code, value: code }))
2859
- });
2860
- }
2861
- }
2862
- };
2863
- const registerLocalesPropertyHandler = () => {
2864
- const { sectionsBuilder } = strapi.service("admin::permission");
2865
- sectionsBuilder.addHandler("singleTypes", localesPropertyHandler);
2866
- sectionsBuilder.addHandler("collectionTypes", localesPropertyHandler);
2867
- };
2868
- const sectionsBuilderService = {
2869
- localesPropertyHandler,
2870
- registerLocalesPropertyHandler
2871
- };
2872
- const willRegisterPermission = (context) => {
2873
- const { permission, condition, user } = context;
2874
- const { subject, properties } = permission;
2875
- const isSuperAdmin = strapi.service("admin::role").hasSuperAdminRole(user);
2876
- if (isSuperAdmin) {
2877
- return;
2878
- }
2879
- const { locales: locales2 } = properties || {};
2880
- const { isLocalizedContentType: isLocalizedContentType2 } = getService("content-types");
2881
- if (!subject) {
2882
- return;
2883
- }
2884
- const ct = strapi.contentTypes[subject];
2885
- if (!isLocalizedContentType2(ct)) {
2886
- return;
2887
- }
2888
- if (locales2 === null) {
2889
- return;
2890
- }
2891
- condition.and({
2892
- locale: {
2893
- $in: locales2 || []
2894
2960
  }
2895
- });
2896
- };
2897
- const registerI18nPermissionsHandlers = () => {
2898
- const { engine } = strapi.service("admin::permission");
2899
- engine.hooks["before-register.permission"].register(willRegisterPermission);
2900
- };
2901
- const engineService = {
2902
- willRegisterPermission,
2903
- registerI18nPermissionsHandlers
2904
- };
2905
- const permissions = () => ({
2906
- actions: i18nActionsService,
2907
- sectionsBuilder: sectionsBuilderService,
2908
- engine: engineService
2909
- });
2910
- const sendDidInitializeEvent = async () => {
2911
- const { isLocalizedContentType: isLocalizedContentType2 } = getService("content-types");
2912
- const numberOfContentTypes = fp.reduce(
2913
- (sum, contentType) => isLocalizedContentType2(contentType) ? sum + 1 : sum,
2914
- 0
2915
- )(strapi.contentTypes);
2916
- await strapi.telemetry.send("didInitializeI18n", { groupProperties: { numberOfContentTypes } });
2917
- };
2918
- const sendDidUpdateI18nLocalesEvent = async () => {
2919
- const numberOfLocales = await getService("locales").count();
2920
- await strapi.telemetry.send("didUpdateI18nLocales", {
2921
- groupProperties: { numberOfLocales }
2922
- });
2923
- };
2924
- const metrics = () => ({
2925
- sendDidInitializeEvent,
2926
- sendDidUpdateI18nLocalesEvent
2927
- });
2928
- const syncNonLocalizedAttributes = async (sourceEntry, model) => {
2929
- const { copyNonLocalizedAttributes: copyNonLocalizedAttributes2 } = getService("content-types");
2930
- const nonLocalizedAttributes = copyNonLocalizedAttributes2(model, sourceEntry);
2931
- if (fp.isEmpty(nonLocalizedAttributes)) {
2932
- return;
2961
+ return { ...matchingLocale };
2933
2962
  }
2934
- const uid = model.uid;
2935
- const documentId = sourceEntry.documentId;
2936
- const locale2 = sourceEntry.locale;
2937
- const status = sourceEntry?.publishedAt ? "published" : "draft";
2938
- const localeEntriesToUpdate = await strapi.db.query(uid).findMany({
2939
- where: {
2940
- documentId,
2941
- publishedAt: status === "published" ? { $ne: null } : null,
2942
- locale: { $ne: locale2 }
2943
- },
2944
- select: ["locale", "id"]
2945
- });
2946
- const entryData = await strapi.documents(uid).omitComponentData(nonLocalizedAttributes);
2947
- await utils.async.map(localeEntriesToUpdate, async (entry) => {
2948
- const transformedData = await strapi.documents.utils.transformData(
2949
- fp.cloneDeep(nonLocalizedAttributes),
2950
- {
2951
- uid,
2952
- status,
2953
- locale: entry.locale,
2954
- allowMissingId: true
2955
- }
2956
- );
2957
- const componentData = await strapi.documents(uid).updateComponents(entry, transformedData);
2958
- await strapi.db.query(uid).update({
2959
- where: {
2960
- documentId,
2961
- publishedAt: status === "published" ? { $ne: null } : null,
2962
- locale: { $eq: entry.locale }
2963
- },
2964
- // The data we send to the update function is the entry data merged with
2965
- // the updated component data
2966
- data: Object.assign(fp.cloneDeep(entryData), componentData)
2967
- });
2968
- });
2963
+ return {
2964
+ code: "en",
2965
+ name: "English (en)"
2966
+ };
2969
2967
  };
2970
- const localizations = () => ({
2971
- syncNonLocalizedAttributes
2972
- });
2968
+ const DEFAULT_LOCALE = getInitLocale();
2973
2969
  const find = (params = {}) => strapi.db.query("plugin::i18n.locale").findMany({ where: params });
2974
2970
  const findById = (id) => strapi.db.query("plugin::i18n.locale").findOne({ where: { id } });
2975
2971
  const findByCode = (code) => strapi.db.query("plugin::i18n.locale").findOne({ where: { code } });
@@ -3037,91 +3033,6 @@ const getIsoLocales = () => isoLocales;
3037
3033
  const isoLocalesService = () => ({
3038
3034
  getIsoLocales
3039
3035
  });
3040
- const LOCALE_QUERY_FILTER = "locale";
3041
- const SINGLE_ENTRY_ACTIONS = ["findOne", "update", "delete"];
3042
- const BULK_ACTIONS = ["delete"];
3043
- const paramsContain = (key, params) => {
3044
- 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));
3045
- };
3046
- const wrapParams = async (params = {}, ctx = {}) => {
3047
- const { action } = ctx;
3048
- if (fp.has(LOCALE_QUERY_FILTER, params)) {
3049
- if (params[LOCALE_QUERY_FILTER] === "all") {
3050
- return fp.omit(LOCALE_QUERY_FILTER, params);
3051
- }
3052
- return {
3053
- ...fp.omit(LOCALE_QUERY_FILTER, params),
3054
- filters: {
3055
- $and: [{ locale: params[LOCALE_QUERY_FILTER] }].concat(params.filters || [])
3056
- }
3057
- };
3058
- }
3059
- const entityDefinedById = paramsContain("id", params) && SINGLE_ENTRY_ACTIONS.includes(action);
3060
- const entitiesDefinedByIds = paramsContain("id.$in", params) && BULK_ACTIONS.includes(action);
3061
- if (entityDefinedById || entitiesDefinedByIds) {
3062
- return params;
3063
- }
3064
- const { getDefaultLocale: getDefaultLocale2 } = getService("locales");
3065
- return {
3066
- ...params,
3067
- filters: {
3068
- $and: [{ locale: await getDefaultLocale2() }].concat(params.filters || [])
3069
- }
3070
- };
3071
- };
3072
- const decorator = (service) => ({
3073
- /**
3074
- * Wraps result
3075
- * @param {object} result - result object of query
3076
- * @param {object} ctx - Query context
3077
- * @param {object} ctx.model - Model that is being used
3078
- */
3079
- async wrapResult(result = {}, ctx = {}) {
3080
- return service.wrapResult.call(this, result, ctx);
3081
- },
3082
- /**
3083
- * Wraps query options. In particular will add default locale to query params
3084
- * @param {object} params - Query options object (params, data, files, populate)
3085
- * @param {object} ctx - Query context
3086
- * @param {object} ctx.model - Model that is being used
3087
- */
3088
- async wrapParams(params = {}, ctx = {}) {
3089
- const wrappedParams = await service.wrapParams.call(this, params, ctx);
3090
- const model = strapi.getModel(ctx.uid);
3091
- const { isLocalizedContentType: isLocalizedContentType2 } = getService("content-types");
3092
- if (!isLocalizedContentType2(model)) {
3093
- return wrappedParams;
3094
- }
3095
- return wrapParams(wrappedParams, ctx);
3096
- },
3097
- /**
3098
- * Find an entry or several if fetching all locales
3099
- * @param {string} uid - Model uid
3100
- * @param {object} opts - Query options object (params, data, files, populate)
3101
- */
3102
- async findMany(uid, opts) {
3103
- const model = strapi.getModel(uid);
3104
- const { isLocalizedContentType: isLocalizedContentType2 } = getService("content-types");
3105
- if (!isLocalizedContentType2(model)) {
3106
- return service.findMany.call(this, uid, opts);
3107
- }
3108
- const { kind } = model;
3109
- if (kind === "singleType") {
3110
- if (opts[LOCALE_QUERY_FILTER] === "all") {
3111
- const wrappedParams = await this.wrapParams(opts, { uid, action: "findMany" });
3112
- const query = strapi.get("query-params").transform(uid, wrappedParams);
3113
- const entities = await strapi.db.query(uid).findMany(query);
3114
- return this.wrapResult(entities, { uid, action: "findMany" });
3115
- }
3116
- return service.findMany.call(this, uid, opts);
3117
- }
3118
- return service.findMany.call(this, uid, opts);
3119
- }
3120
- });
3121
- const entityServiceDecorator = () => ({
3122
- decorator,
3123
- wrapParams
3124
- });
3125
3036
  const {
3126
3037
  isRelationalAttribute,
3127
3038
  getVisibleAttributes,
@@ -3252,7 +3163,6 @@ const services = {
3252
3163
  localizations,
3253
3164
  locales,
3254
3165
  "iso-locales": isoLocalesService,
3255
- "entity-service-decorator": entityServiceDecorator,
3256
3166
  "content-types": contentTypes
3257
3167
  };
3258
3168
  const admin = {