@strapi/core 5.40.0 → 5.41.0

package/dist/package.json.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var name = "@strapi/core";
-var version = "5.40.0";
+var version = "5.41.0";
 var description = "Core of Strapi";
 var homepage = "https://strapi.io";
 var bugs = {
@@ -62,14 +62,14 @@ var dependencies = {
     "@koa/cors": "5.0.0",
     "@koa/router": "12.0.2",
     "@paralleldrive/cuid2": "2.2.2",
-    "@strapi/admin": "5.40.0",
-    "@strapi/database": "5.40.0",
-    "@strapi/generators": "5.40.0",
-    "@strapi/logger": "5.40.0",
-    "@strapi/permissions": "5.40.0",
-    "@strapi/types": "5.40.0",
-    "@strapi/typescript-utils": "5.40.0",
-    "@strapi/utils": "5.40.0",
+    "@strapi/admin": "5.41.0",
+    "@strapi/database": "5.41.0",
+    "@strapi/generators": "5.41.0",
+    "@strapi/logger": "5.41.0",
+    "@strapi/permissions": "5.41.0",
+    "@strapi/types": "5.41.0",
+    "@strapi/typescript-utils": "5.41.0",
+    "@strapi/utils": "5.41.0",
     "@vercel/stega": "0.1.2",
     bcryptjs: "2.4.3",
     boxen: "5.1.2",
@@ -78,16 +78,15 @@ var dependencies = {
     "cli-table3": "0.6.5",
     commander: "8.3.0",
     configstore: "5.0.1",
-    copyfiles: "2.4.1",
     debug: "4.3.4",
     delegates: "1.0.0",
     dotenv: "16.4.5",
     execa: "5.1.1",
     "fs-extra": "11.2.0",
-    glob: "13.0.0",
-    "global-agent": "3.0.0",
+    glob: "13.0.6",
+    "global-agent": "4.1.3",
     "http-errors": "2.0.0",
-    inquirer: "8.2.5",
+    inquirer: "9.3.8",
     "is-docker": "2.2.1",
     "json-logic-js": "2.0.5",
     jsonwebtoken: "9.0.0",
@@ -112,7 +111,7 @@ var dependencies = {
     semver: "7.5.4",
     statuses: "2.0.1",
     typescript: "5.4.4",
-    undici: "6.23.0",
+    undici: "6.24.0",
     yup: "0.32.9",
     zod: "3.25.67"
 };
@@ -123,7 +122,7 @@ var devDependencies = {
     "@types/configstore": "5.0.1",
     "@types/delegates": "1.0.0",
     "@types/fs-extra": "11.0.4",
-    "@types/global-agent": "2.1.3",
+    "@types/global-agent": "3.0.0",
     "@types/http-errors": "2.0.4",
     "@types/jest": "29.5.2",
     "@types/json-logic-js": "2.0.8",
@@ -137,11 +136,11 @@ var devDependencies = {
     "@types/node": "24.10.0",
     "@types/node-schedule": "2.1.7",
     "@types/statuses": "2.0.1",
-    "eslint-config-custom": "5.40.0",
-    supertest: "6.3.3",
-    tsconfig: "5.40.0",
+    "eslint-config-custom": "5.41.0",
+    supertest: "7.2.2",
+    tsconfig: "5.41.0",
     vitest: "catalog:",
-    "vitest-config": "5.40.0"
+    "vitest-config": "5.41.0"
 };
 var engines = {
     node: ">=20.0.0 <=24.x.x",

package/dist/package.json.js.map

@@ -1 +1 @@
-{"version":3,"file":"package.json.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"package.json.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/package.json.mjs

@@ -1,5 +1,5 @@
 var name = "@strapi/core";
-var version = "5.40.0";
+var version = "5.41.0";
 var description = "Core of Strapi";
 var homepage = "https://strapi.io";
 var bugs = {
@@ -58,14 +58,14 @@ var dependencies = {
     "@koa/cors": "5.0.0",
     "@koa/router": "12.0.2",
     "@paralleldrive/cuid2": "2.2.2",
-    "@strapi/admin": "5.40.0",
-    "@strapi/database": "5.40.0",
-    "@strapi/generators": "5.40.0",
-    "@strapi/logger": "5.40.0",
-    "@strapi/permissions": "5.40.0",
-    "@strapi/types": "5.40.0",
-    "@strapi/typescript-utils": "5.40.0",
-    "@strapi/utils": "5.40.0",
+    "@strapi/admin": "5.41.0",
+    "@strapi/database": "5.41.0",
+    "@strapi/generators": "5.41.0",
+    "@strapi/logger": "5.41.0",
+    "@strapi/permissions": "5.41.0",
+    "@strapi/types": "5.41.0",
+    "@strapi/typescript-utils": "5.41.0",
+    "@strapi/utils": "5.41.0",
     "@vercel/stega": "0.1.2",
     bcryptjs: "2.4.3",
     boxen: "5.1.2",
@@ -74,16 +74,15 @@ var dependencies = {
     "cli-table3": "0.6.5",
     commander: "8.3.0",
     configstore: "5.0.1",
-    copyfiles: "2.4.1",
     debug: "4.3.4",
     delegates: "1.0.0",
     dotenv: "16.4.5",
     execa: "5.1.1",
     "fs-extra": "11.2.0",
-    glob: "13.0.0",
-    "global-agent": "3.0.0",
+    glob: "13.0.6",
+    "global-agent": "4.1.3",
     "http-errors": "2.0.0",
-    inquirer: "8.2.5",
+    inquirer: "9.3.8",
     "is-docker": "2.2.1",
     "json-logic-js": "2.0.5",
     jsonwebtoken: "9.0.0",
@@ -108,7 +107,7 @@ var dependencies = {
     semver: "7.5.4",
     statuses: "2.0.1",
     typescript: "5.4.4",
-    undici: "6.23.0",
+    undici: "6.24.0",
     yup: "0.32.9",
     zod: "3.25.67"
 };
@@ -119,7 +118,7 @@ var devDependencies = {
     "@types/configstore": "5.0.1",
     "@types/delegates": "1.0.0",
     "@types/fs-extra": "11.0.4",
-    "@types/global-agent": "2.1.3",
+    "@types/global-agent": "3.0.0",
     "@types/http-errors": "2.0.4",
     "@types/jest": "29.5.2",
     "@types/json-logic-js": "2.0.8",
@@ -133,11 +132,11 @@ var devDependencies = {
     "@types/node": "24.10.0",
     "@types/node-schedule": "2.1.7",
     "@types/statuses": "2.0.1",
-    "eslint-config-custom": "5.40.0",
-    supertest: "6.3.3",
-    tsconfig: "5.40.0",
+    "eslint-config-custom": "5.41.0",
+    supertest: "7.2.2",
+    tsconfig: "5.41.0",
     vitest: "catalog:",
-    "vitest-config": "5.40.0"
+    "vitest-config": "5.41.0"
 };
 var engines = {
     node: ">=20.0.0 <=24.x.x",

package/dist/package.json.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"package.json.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"package.json.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/services/document-service/utils/bidirectional-relations.d.ts

@@ -1,4 +1,5 @@
 import type { UID } from '@strapi/types';
+import type { JoinTable } from '@strapi/database';
 interface LoadContext {
     oldVersions: {
         id: string;
@@ -9,6 +10,10 @@ interface LoadContext {
         locale: string;
     }[];
 }
+interface RelationEntry {
+    joinTable: JoinTable;
+    relations: Record<string, unknown>[];
+}
 /**
  * Loads all bidirectional relations that need to be synchronized when content entries change state
  * (e.g., during publish/unpublish operations).
@@ -54,7 +59,7 @@ interface LoadContext {
  * @param context - Object containing arrays of old and new entry versions
  * @returns Array of objects containing join table metadata and relations to be updated
  */
-declare const load: (uid: UID.ContentType, { oldVersions }: LoadContext) => Promise<any>;
+declare const load: (uid: UID.ContentType, { oldVersions }: LoadContext) => Promise<RelationEntry[]>;
 /**
  * Synchronizes the order of bidirectional relations after content entries have changed state.
  *
@@ -87,9 +92,6 @@ declare const sync: (oldEntries: {
 }[], newEntries: {
     id: string;
     locale: string;
-}[], existingRelations: {
-    joinTable: any;
-    relations: any[];
-}[]) => Promise<void>;
+}[], existingRelations: RelationEntry[]) => Promise<void>;
 export { load, sync };
 //# sourceMappingURL=bidirectional-relations.d.ts.map

package/dist/services/document-service/utils/bidirectional-relations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bidirectional-relations.d.ts","sourceRoot":"","sources":["../../../../src/services/document-service/utils/bidirectional-relations.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,GAAG,EAAU,MAAM,eAAe,CAAC;AAEjD,UAAU,WAAW;IACnB,WAAW,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAC9C,WAAW,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CAC/C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,QAAA,MAAM,IAAI,QAAe,IAAI,WAAW,mBAAmB,WAAW,iBAmDrE,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,QAAA,MAAM,IAAI,eACI;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,EAAE,cAChC;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,EAAE,qBACzB;IAAE,SAAS,EAAE,GAAG,CAAC;IAAC,SAAS,EAAE,GAAG,EAAE,CAAA;CAAE,EAAE,kBA6C1D,CAAC;AAEF,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC"}
+{"version":3,"file":"bidirectional-relations.d.ts","sourceRoot":"","sources":["../../../../src/services/document-service/utils/bidirectional-relations.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,GAAG,EAAU,MAAM,eAAe,CAAC;AACjD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAElD,UAAU,WAAW;IACnB,WAAW,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAC9C,WAAW,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CAC/C;AAED,UAAU,aAAa;IACrB,SAAS,EAAE,SAAS,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;CACtC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,QAAA,MAAM,IAAI,QAAe,IAAI,WAAW,mBAAmB,WAAW,6BAmDrE,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,QAAA,MAAM,IAAI,eACI;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,EAAE,cAChC;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,EAAE,qBACzB,aAAa,EAAE,kBAyFnC,CAAC;AAEF,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC"}

package/dist/services/document-service/utils/bidirectional-relations.js

@@ -1,7 +1,6 @@
 'use strict';
 
 var fp = require('lodash/fp');
-var strapiUtils = require('@strapi/utils');
 
 /**
  * Loads all bidirectional relations that need to be synchronized when content entries change state
@@ -121,6 +120,8 @@ var strapiUtils = require('@strapi/utils');
         acc[oldEntry.id] = newEntry.id;
         return acc;
     }, {});
+    const republishedEntryIds = new Set(newEntries.map((e)=>String(e.id)));
+    const isRepublishedEntry = (id)=>republishedEntryIds.has(String(id));
     await strapi.db.transaction(async ({ trx })=>{
         for (const { joinTable, relations } of existingRelations){
             const sourceColumn = joinTable.inverseJoinColumn.name;
@@ -130,15 +131,42 @@ var strapiUtils = require('@strapi/utils');
             if (!sourceColumn || !targetColumn || !orderColumn) {
                 continue;
             }
-            // Update order values for each relation
-            // TODO: Find a way to batch it more efficiently
-            await strapiUtils.async.map(relations, (relation)=>{
-                const { [sourceColumn]: oldSourceId, [targetColumn]: targetId, [orderColumn]: originalOrder } = relation;
-                // Update the order column for the new relation entry
-                return trx.from(joinTable.name).where(sourceColumn, entryIdMapping[oldSourceId]).where(targetColumn, targetId).update({
-                    [orderColumn]: originalOrder
-                });
+            const mappedRelations = relations.map((relation)=>({
+                    relation,
+                    oldSourceId: relation[sourceColumn],
+                    targetId: relation[targetColumn],
+                    originalOrder: relation[orderColumn],
+                    newSourceId: entryIdMapping[relation[sourceColumn]]
+                })).filter((r)=>Boolean(r.newSourceId));
+            if (!mappedRelations.length) continue;
+            const newSourceIds = mappedRelations.map((r)=>r.newSourceId);
+            // Batch UPDATE: set each row's order in a single statement using CASE
+            const caseFragments = mappedRelations.map(()=>`WHEN ?? = ? AND ?? = ? THEN ?`);
+            const caseBindings = mappedRelations.flatMap(({ newSourceId, targetId, originalOrder })=>[
+                    sourceColumn,
+                    newSourceId,
+                    targetColumn,
+                    targetId,
+                    originalOrder
+                ]);
+            await trx(joinTable.name).whereIn(sourceColumn, newSourceIds).update({
+                [orderColumn]: trx.raw(`CASE ${caseFragments.join(' ')} ELSE ?? END`, [
+                    ...caseBindings,
+                    orderColumn
+                ])
             });
+            // Batch SELECT: find which rows exist so we know what to insert
+            const existingRows = await trx(joinTable.name).whereIn(sourceColumn, newSourceIds).select(sourceColumn, targetColumn);
+            const existingSet = new Set(existingRows.map((r)=>`${r[sourceColumn]}:${r[targetColumn]}`));
+            // Batch INSERT: insert cascade-deleted rows that aren't from republished sources
+            const toInsert = mappedRelations.filter(({ newSourceId, targetId })=>!existingSet.has(`${newSourceId}:${targetId}`) && !isRepublishedEntry(newSourceId)).map(({ relation, newSourceId, originalOrder })=>({
+                    ...fp.omit(strapi.db.metadata.identifiers.ID_COLUMN, relation),
+                    [sourceColumn]: newSourceId,
+                    [orderColumn]: originalOrder
+                }));
+            if (toInsert.length) {
+                await trx.batchInsert(joinTable.name, toInsert, 1000);
+            }
         }
     });
 };

package/dist/services/document-service/utils/bidirectional-relations.js.map

@@ -1 +1 @@
-{"version":3,"file":"bidirectional-relations.js","sources":["../../../../src/services/document-service/utils/bidirectional-relations.ts"],"sourcesContent":["/* eslint-disable no-continue */\nimport { keyBy } from 'lodash/fp';\nimport { async } from '@strapi/utils';\nimport type { UID, Schema } from '@strapi/types';\n\ninterface LoadContext {\n  oldVersions: { id: string; locale: string }[];\n  newVersions: { id: string; locale: string }[];\n}\n\n/**\n * Loads all bidirectional relations that need to be synchronized when content entries change state\n * (e.g., during publish/unpublish operations).\n *\n * In Strapi, bidirectional relations allow maintaining order from both sides of the relation.\n * When an entry is published, the following occurs:\n *\n * 1. The old published entry is deleted\n * 2. A new entry is created with all its relations\n *\n * This process affects relation ordering in the following way:\n *\n * Initial state (Entry A related to X, Y, Z):\n * ```\n *   Entry A (draft)     Entry A (published)\n *      │                     │\n *      ├──(1)→ X            ├──(1)→ X\n *      ├──(2)→ Y            ├──(2)→ Y\n *      └──(3)→ Z            └──(3)→ Z\n *\n *   X's perspective:         Y's perspective:         Z's perspective:\n *      └──(2)→ Entry A         └──(1)→ Entry A         └──(3)→ Entry A\n * ```\n *\n * After publishing Entry A (without relation order sync):\n * ```\n *   Entry A (draft)     Entry A (new published)\n *      │                     │\n *      ├──(1)→ X            ├──(1)→ X\n *      ├──(2)→ Y            ├──(2)→ Y\n *      └──(3)→ Z            └──(3)→ Z\n *\n *   X's perspective:         Y's perspective:         Z's perspective:\n *      └──(3)→ Entry A         └──(3)→ Entry A         └──(3)→ Entry A\n *                           (all relations appear last in order)\n * ```\n *\n * This module preserves the original ordering from both perspectives by:\n * 1. Capturing the relation order before the entry state changes\n * 2. Restoring this order after the new relations are created\n *\n * @param uid - The unique identifier of the content type being processed\n * @param context - Object containing arrays of old and new entry versions\n * @returns Array of objects containing join table metadata and relations to be updated\n */\nconst load = async (uid: UID.ContentType, { oldVersions }: LoadContext) => {\n  const relationsToUpdate = [] as any;\n\n  await strapi.db.transaction(async ({ trx }) => {\n    const contentTypes = Object.values(strapi.contentTypes) as Schema.ContentType[];\n    const components = Object.values(strapi.components) as Schema.Component[];\n\n    for (const model of [...contentTypes, ...components]) {\n      const dbModel = strapi.db.metadata.get(model.uid);\n\n      for (const attribute of Object.values(dbModel.attributes) as any) {\n        // Skip if not a bidirectional relation targeting our content type\n        if (\n          attribute.type !== 'relation' ||\n          attribute.target !== uid ||\n          !(attribute.inversedBy || attribute.mappedBy)\n        ) {\n          continue;\n        }\n\n        // If it's a self referencing relation, there is no need to sync any relation\n        // The order will already be handled as both sides are inside the same content type\n        if (model.uid === uid) {\n          continue;\n        }\n\n        const joinTable = attribute.joinTable;\n        if (!joinTable) {\n          continue;\n        }\n\n        const { name: targetColumnName } = joinTable.inverseJoinColumn;\n\n        // Load all relations that need their order preserved\n        const oldEntryIds = oldVersions.map((entry) => entry.id);\n\n        const existingRelations = await strapi.db\n          .getConnection()\n          .select('*')\n          .from(joinTable.name)\n          .whereIn(targetColumnName, oldEntryIds)\n          .transacting(trx);\n\n        if (existingRelations.length > 0) {\n          relationsToUpdate.push({ joinTable, relations: existingRelations });\n        }\n      }\n    }\n  });\n\n  return relationsToUpdate;\n};\n\n/**\n * Synchronizes the order of bidirectional relations after content entries have changed state.\n *\n * When entries change state (e.g., draft → published), their IDs change and all relations are recreated.\n * While the order of relations from the entry's perspective is maintained (as they're created in order),\n * the inverse relations (from related entries' perspective) would all appear last in order since they're new.\n *\n * Example:\n * ```\n * Before publish:\n *   Article(id:1) →(order:1)→ Category(id:5)\n *   Category(id:5) →(order:3)→ Article(id:1)\n *\n * After publish (without sync):\n *   Article(id:2) →(order:1)→ Category(id:5)    [order preserved]\n *   Category(id:5) →(order:99)→ Article(id:2)   [order lost - appears last]\n *\n * After sync:\n *   Article(id:2) →(order:1)→ Category(id:5)    [order preserved]\n *   Category(id:5) →(order:3)→ Article(id:2)    [order restored]\n * ```\n *\n * @param oldEntries - Array of previous entry versions with their IDs and locales\n * @param newEntries - Array of new entry versions with their IDs and locales\n * @param existingRelations - Array of join table data containing the relations to be updated\n */\nconst sync = async (\n  oldEntries: { id: string; locale: string }[],\n  newEntries: { id: string; locale: string }[],\n  existingRelations: { joinTable: any; relations: any[] }[]\n) => {\n  // Group new entries by locale for easier lookup\n  const newEntriesByLocale = keyBy('locale', newEntries);\n\n  // Create a mapping of old entry IDs to new entry IDs based on locale\n  const entryIdMapping = oldEntries.reduce(\n    (acc, oldEntry) => {\n      const newEntry = newEntriesByLocale[oldEntry.locale];\n      if (!newEntry) return acc;\n      acc[oldEntry.id] = newEntry.id;\n      return acc;\n    },\n    {} as Record<string, string>\n  );\n\n  await strapi.db.transaction(async ({ trx }) => {\n    for (const { joinTable, relations } of existingRelations) {\n      const sourceColumn = joinTable.inverseJoinColumn.name;\n      const targetColumn = joinTable.joinColumn.name;\n      const orderColumn = joinTable.orderColumnName;\n\n      // Failsafe in case those don't exist\n      if (!sourceColumn || !targetColumn || !orderColumn) {\n        continue;\n      }\n\n      // Update order values for each relation\n      // TODO: Find a way to batch it more efficiently\n      await async.map(relations, (relation: any) => {\n        const {\n          [sourceColumn]: oldSourceId,\n          [targetColumn]: targetId,\n          [orderColumn]: originalOrder,\n        } = relation;\n\n        // Update the order column for the new relation entry\n        return trx\n          .from(joinTable.name)\n          .where(sourceColumn, entryIdMapping[oldSourceId])\n          .where(targetColumn, targetId)\n          .update({ [orderColumn]: originalOrder });\n      });\n    }\n  });\n};\n\nexport { load, sync };\n"],"names":["load","uid","oldVersions","relationsToUpdate","strapi","db","transaction","trx","contentTypes","Object","values","components","model","dbModel","metadata","get","attribute","attributes","type","target","inversedBy","mappedBy","joinTable","name","targetColumnName","inverseJoinColumn","oldEntryIds","map","entry","id","existingRelations","getConnection","select","from","whereIn","transacting","length","push","relations","sync","oldEntries","newEntries","newEntriesByLocale","keyBy","entryIdMapping","reduce","acc","oldEntry","newEntry","locale","sourceColumn","targetColumn","joinColumn","orderColumn","orderColumnName","async","relation","oldSourceId","targetId","originalOrder","where","update"],"mappings":"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"}
+{"version":3,"file":"bidirectional-relations.js","sources":["../../../../src/services/document-service/utils/bidirectional-relations.ts"],"sourcesContent":["/* eslint-disable no-continue */\nimport { keyBy, omit } from 'lodash/fp';\nimport type { UID, Schema } from '@strapi/types';\nimport type { JoinTable } from '@strapi/database';\n\ninterface LoadContext {\n  oldVersions: { id: string; locale: string }[];\n  newVersions: { id: string; locale: string }[];\n}\n\ninterface RelationEntry {\n  joinTable: JoinTable;\n  relations: Record<string, unknown>[];\n}\n\n/**\n * Loads all bidirectional relations that need to be synchronized when content entries change state\n * (e.g., during publish/unpublish operations).\n *\n * In Strapi, bidirectional relations allow maintaining order from both sides of the relation.\n * When an entry is published, the following occurs:\n *\n * 1. The old published entry is deleted\n * 2. A new entry is created with all its relations\n *\n * This process affects relation ordering in the following way:\n *\n * Initial state (Entry A related to X, Y, Z):\n * ```\n *   Entry A (draft)     Entry A (published)\n *      │                     │\n *      ├──(1)→ X            ├──(1)→ X\n *      ├──(2)→ Y            ├──(2)→ Y\n *      └──(3)→ Z            └──(3)→ Z\n *\n *   X's perspective:         Y's perspective:         Z's perspective:\n *      └──(2)→ Entry A         └──(1)→ Entry A         └──(3)→ Entry A\n * ```\n *\n * After publishing Entry A (without relation order sync):\n * ```\n *   Entry A (draft)     Entry A (new published)\n *      │                     │\n *      ├──(1)→ X            ├──(1)→ X\n *      ├──(2)→ Y            ├──(2)→ Y\n *      └──(3)→ Z            └──(3)→ Z\n *\n *   X's perspective:         Y's perspective:         Z's perspective:\n *      └──(3)→ Entry A         └──(3)→ Entry A         └──(3)→ Entry A\n *                           (all relations appear last in order)\n * ```\n *\n * This module preserves the original ordering from both perspectives by:\n * 1. Capturing the relation order before the entry state changes\n * 2. Restoring this order after the new relations are created\n *\n * @param uid - The unique identifier of the content type being processed\n * @param context - Object containing arrays of old and new entry versions\n * @returns Array of objects containing join table metadata and relations to be updated\n */\nconst load = async (uid: UID.ContentType, { oldVersions }: LoadContext) => {\n  const relationsToUpdate: RelationEntry[] = [];\n\n  await strapi.db.transaction(async ({ trx }) => {\n    const contentTypes = Object.values(strapi.contentTypes) as Schema.ContentType[];\n    const components = Object.values(strapi.components) as Schema.Component[];\n\n    for (const model of [...contentTypes, ...components]) {\n      const dbModel = strapi.db.metadata.get(model.uid);\n\n      for (const attribute of Object.values(dbModel.attributes) as Record<string, any>[]) {\n        // Skip if not a bidirectional relation targeting our content type\n        if (\n          attribute.type !== 'relation' ||\n          attribute.target !== uid ||\n          !(attribute.inversedBy || attribute.mappedBy)\n        ) {\n          continue;\n        }\n\n        // If it's a self referencing relation, there is no need to sync any relation\n        // The order will already be handled as both sides are inside the same content type\n        if (model.uid === uid) {\n          continue;\n        }\n\n        const joinTable = attribute.joinTable;\n        if (!joinTable) {\n          continue;\n        }\n\n        const { name: targetColumnName } = joinTable.inverseJoinColumn;\n\n        // Load all relations that need their order preserved\n        const oldEntryIds = oldVersions.map((entry) => entry.id);\n\n        const existingRelations = await strapi.db\n          .getConnection()\n          .select('*')\n          .from(joinTable.name)\n          .whereIn(targetColumnName, oldEntryIds)\n          .transacting(trx);\n\n        if (existingRelations.length > 0) {\n          relationsToUpdate.push({ joinTable, relations: existingRelations });\n        }\n      }\n    }\n  });\n\n  return relationsToUpdate;\n};\n\n/**\n * Synchronizes the order of bidirectional relations after content entries have changed state.\n *\n * When entries change state (e.g., draft → published), their IDs change and all relations are recreated.\n * While the order of relations from the entry's perspective is maintained (as they're created in order),\n * the inverse relations (from related entries' perspective) would all appear last in order since they're new.\n *\n * Example:\n * ```\n * Before publish:\n *   Article(id:1) →(order:1)→ Category(id:5)\n *   Category(id:5) →(order:3)→ Article(id:1)\n *\n * After publish (without sync):\n *   Article(id:2) →(order:1)→ Category(id:5)    [order preserved]\n *   Category(id:5) →(order:99)→ Article(id:2)   [order lost - appears last]\n *\n * After sync:\n *   Article(id:2) →(order:1)→ Category(id:5)    [order preserved]\n *   Category(id:5) →(order:3)→ Article(id:2)    [order restored]\n * ```\n *\n * @param oldEntries - Array of previous entry versions with their IDs and locales\n * @param newEntries - Array of new entry versions with their IDs and locales\n * @param existingRelations - Array of join table data containing the relations to be updated\n */\nconst sync = async (\n  oldEntries: { id: string; locale: string }[],\n  newEntries: { id: string; locale: string }[],\n  existingRelations: RelationEntry[]\n) => {\n  // Group new entries by locale for easier lookup\n  const newEntriesByLocale = keyBy('locale', newEntries);\n\n  // Create a mapping of old entry IDs to new entry IDs based on locale\n  const entryIdMapping = oldEntries.reduce(\n    (acc, oldEntry) => {\n      const newEntry = newEntriesByLocale[oldEntry.locale];\n      if (!newEntry) return acc;\n      acc[oldEntry.id] = newEntry.id;\n      return acc;\n    },\n    {} as Record<string, string>\n  );\n\n  const republishedEntryIds = new Set(newEntries.map((e) => String(e.id)));\n  const isRepublishedEntry = (id: string | number) => republishedEntryIds.has(String(id));\n\n  await strapi.db.transaction(async ({ trx }) => {\n    for (const { joinTable, relations } of existingRelations) {\n      const sourceColumn = joinTable.inverseJoinColumn.name;\n      const targetColumn = joinTable.joinColumn.name;\n      const orderColumn = joinTable.orderColumnName;\n\n      // Failsafe in case those don't exist\n      if (!sourceColumn || !targetColumn || !orderColumn) {\n        continue;\n      }\n\n      const mappedRelations = relations\n        .map((relation) => ({\n          relation,\n          oldSourceId: relation[sourceColumn] as string,\n          targetId: relation[targetColumn] as string,\n          originalOrder: relation[orderColumn],\n          newSourceId: entryIdMapping[relation[sourceColumn] as string],\n        }))\n        .filter((r): r is typeof r & { newSourceId: string } => Boolean(r.newSourceId));\n\n      if (!mappedRelations.length) continue;\n\n      const newSourceIds = mappedRelations.map((r) => r.newSourceId);\n\n      // Batch UPDATE: set each row's order in a single statement using CASE\n      const caseFragments = mappedRelations.map(() => `WHEN ?? = ? AND ?? = ? THEN ?`);\n      const caseBindings = mappedRelations.flatMap(({ newSourceId, targetId, originalOrder }) => [\n        sourceColumn,\n        newSourceId,\n        targetColumn,\n        targetId,\n        originalOrder,\n      ]);\n\n      await trx(joinTable.name)\n        .whereIn(sourceColumn, newSourceIds)\n        .update({\n          [orderColumn]: trx.raw(`CASE ${caseFragments.join(' ')} ELSE ?? END`, [\n            ...caseBindings,\n            orderColumn,\n          ]),\n        });\n\n      // Batch SELECT: find which rows exist so we know what to insert\n      const existingRows = await trx(joinTable.name)\n        .whereIn(sourceColumn, newSourceIds)\n        .select(sourceColumn, targetColumn);\n\n      const existingSet = new Set(\n        existingRows.map((r: Record<string, unknown>) => `${r[sourceColumn]}:${r[targetColumn]}`)\n      );\n\n      // Batch INSERT: insert cascade-deleted rows that aren't from republished sources\n      const toInsert = mappedRelations\n        .filter(\n          ({ newSourceId, targetId }) =>\n            !existingSet.has(`${newSourceId}:${targetId}`) && !isRepublishedEntry(newSourceId)\n        )\n        .map(({ relation, newSourceId, originalOrder }) => ({\n          ...omit(strapi.db.metadata.identifiers.ID_COLUMN, relation),\n          [sourceColumn]: newSourceId,\n          [orderColumn]: originalOrder,\n        }));\n\n      if (toInsert.length) {\n        await trx.batchInsert(joinTable.name, toInsert, 1000);\n      }\n    }\n  });\n};\n\nexport { load, sync };\n"],"names":["load","uid","oldVersions","relationsToUpdate","strapi","db","transaction","trx","contentTypes","Object","values","components","model","dbModel","metadata","get","attribute","attributes","type","target","inversedBy","mappedBy","joinTable","name","targetColumnName","inverseJoinColumn","oldEntryIds","map","entry","id","existingRelations","getConnection","select","from","whereIn","transacting","length","push","relations","sync","oldEntries","newEntries","newEntriesByLocale","keyBy","entryIdMapping","reduce","acc","oldEntry","newEntry","locale","republishedEntryIds","Set","e","String","isRepublishedEntry","has","sourceColumn","targetColumn","joinColumn","orderColumn","orderColumnName","mappedRelations","relation","oldSourceId","targetId","originalOrder","newSourceId","filter","r","Boolean","newSourceIds","caseFragments","caseBindings","flatMap","update","raw","join","existingRows","existingSet","toInsert","omit","identifiers","ID_COLUMN","batchInsert"],"mappings":"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"}

package/dist/services/document-service/utils/bidirectional-relations.mjs

@@ -1,5 +1,4 @@
-import { keyBy } from 'lodash/fp';
-import { async } from '@strapi/utils';
+import { keyBy, omit } from 'lodash/fp';
 
 /**
  * Loads all bidirectional relations that need to be synchronized when content entries change state
@@ -119,6 +118,8 @@ import { async } from '@strapi/utils';
         acc[oldEntry.id] = newEntry.id;
         return acc;
     }, {});
+    const republishedEntryIds = new Set(newEntries.map((e)=>String(e.id)));
+    const isRepublishedEntry = (id)=>republishedEntryIds.has(String(id));
     await strapi.db.transaction(async ({ trx })=>{
         for (const { joinTable, relations } of existingRelations){
             const sourceColumn = joinTable.inverseJoinColumn.name;
@@ -128,15 +129,42 @@ import { async } from '@strapi/utils';
             if (!sourceColumn || !targetColumn || !orderColumn) {
                 continue;
             }
-            // Update order values for each relation
-            // TODO: Find a way to batch it more efficiently
-            await async.map(relations, (relation)=>{
-                const { [sourceColumn]: oldSourceId, [targetColumn]: targetId, [orderColumn]: originalOrder } = relation;
-                // Update the order column for the new relation entry
-                return trx.from(joinTable.name).where(sourceColumn, entryIdMapping[oldSourceId]).where(targetColumn, targetId).update({
-                    [orderColumn]: originalOrder
-                });
+            const mappedRelations = relations.map((relation)=>({
+                    relation,
+                    oldSourceId: relation[sourceColumn],
+                    targetId: relation[targetColumn],
+                    originalOrder: relation[orderColumn],
+                    newSourceId: entryIdMapping[relation[sourceColumn]]
+                })).filter((r)=>Boolean(r.newSourceId));
+            if (!mappedRelations.length) continue;
+            const newSourceIds = mappedRelations.map((r)=>r.newSourceId);
+            // Batch UPDATE: set each row's order in a single statement using CASE
+            const caseFragments = mappedRelations.map(()=>`WHEN ?? = ? AND ?? = ? THEN ?`);
+            const caseBindings = mappedRelations.flatMap(({ newSourceId, targetId, originalOrder })=>[
+                    sourceColumn,
+                    newSourceId,
+                    targetColumn,
+                    targetId,
+                    originalOrder
+                ]);
+            await trx(joinTable.name).whereIn(sourceColumn, newSourceIds).update({
+                [orderColumn]: trx.raw(`CASE ${caseFragments.join(' ')} ELSE ?? END`, [
+                    ...caseBindings,
+                    orderColumn
+                ])
             });
+            // Batch SELECT: find which rows exist so we know what to insert
+            const existingRows = await trx(joinTable.name).whereIn(sourceColumn, newSourceIds).select(sourceColumn, targetColumn);
+            const existingSet = new Set(existingRows.map((r)=>`${r[sourceColumn]}:${r[targetColumn]}`));
+            // Batch INSERT: insert cascade-deleted rows that aren't from republished sources
+            const toInsert = mappedRelations.filter(({ newSourceId, targetId })=>!existingSet.has(`${newSourceId}:${targetId}`) && !isRepublishedEntry(newSourceId)).map(({ relation, newSourceId, originalOrder })=>({
+                    ...omit(strapi.db.metadata.identifiers.ID_COLUMN, relation),
+                    [sourceColumn]: newSourceId,
+                    [orderColumn]: originalOrder
+                }));
+            if (toInsert.length) {
+                await trx.batchInsert(joinTable.name, toInsert, 1000);
+            }
         }
     });
 };

package/dist/services/document-service/utils/bidirectional-relations.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"bidirectional-relations.mjs","sources":["../../../../src/services/document-service/utils/bidirectional-relations.ts"],"sourcesContent":["/* eslint-disable no-continue */\nimport { keyBy } from 'lodash/fp';\nimport { async } from '@strapi/utils';\nimport type { UID, Schema } from '@strapi/types';\n\ninterface LoadContext {\n  oldVersions: { id: string; locale: string }[];\n  newVersions: { id: string; locale: string }[];\n}\n\n/**\n * Loads all bidirectional relations that need to be synchronized when content entries change state\n * (e.g., during publish/unpublish operations).\n *\n * In Strapi, bidirectional relations allow maintaining order from both sides of the relation.\n * When an entry is published, the following occurs:\n *\n * 1. The old published entry is deleted\n * 2. A new entry is created with all its relations\n *\n * This process affects relation ordering in the following way:\n *\n * Initial state (Entry A related to X, Y, Z):\n * ```\n *   Entry A (draft)     Entry A (published)\n *      │                     │\n *      ├──(1)→ X            ├──(1)→ X\n *      ├──(2)→ Y            ├──(2)→ Y\n *      └──(3)→ Z            └──(3)→ Z\n *\n *   X's perspective:         Y's perspective:         Z's perspective:\n *      └──(2)→ Entry A         └──(1)→ Entry A         └──(3)→ Entry A\n * ```\n *\n * After publishing Entry A (without relation order sync):\n * ```\n *   Entry A (draft)     Entry A (new published)\n *      │                     │\n *      ├──(1)→ X            ├──(1)→ X\n *      ├──(2)→ Y            ├──(2)→ Y\n *      └──(3)→ Z            └──(3)→ Z\n *\n *   X's perspective:         Y's perspective:         Z's perspective:\n *      └──(3)→ Entry A         └──(3)→ Entry A         └──(3)→ Entry A\n *                           (all relations appear last in order)\n * ```\n *\n * This module preserves the original ordering from both perspectives by:\n * 1. Capturing the relation order before the entry state changes\n * 2. Restoring this order after the new relations are created\n *\n * @param uid - The unique identifier of the content type being processed\n * @param context - Object containing arrays of old and new entry versions\n * @returns Array of objects containing join table metadata and relations to be updated\n */\nconst load = async (uid: UID.ContentType, { oldVersions }: LoadContext) => {\n  const relationsToUpdate = [] as any;\n\n  await strapi.db.transaction(async ({ trx }) => {\n    const contentTypes = Object.values(strapi.contentTypes) as Schema.ContentType[];\n    const components = Object.values(strapi.components) as Schema.Component[];\n\n    for (const model of [...contentTypes, ...components]) {\n      const dbModel = strapi.db.metadata.get(model.uid);\n\n      for (const attribute of Object.values(dbModel.attributes) as any) {\n        // Skip if not a bidirectional relation targeting our content type\n        if (\n          attribute.type !== 'relation' ||\n          attribute.target !== uid ||\n          !(attribute.inversedBy || attribute.mappedBy)\n        ) {\n          continue;\n        }\n\n        // If it's a self referencing relation, there is no need to sync any relation\n        // The order will already be handled as both sides are inside the same content type\n        if (model.uid === uid) {\n          continue;\n        }\n\n        const joinTable = attribute.joinTable;\n        if (!joinTable) {\n          continue;\n        }\n\n        const { name: targetColumnName } = joinTable.inverseJoinColumn;\n\n        // Load all relations that need their order preserved\n        const oldEntryIds = oldVersions.map((entry) => entry.id);\n\n        const existingRelations = await strapi.db\n          .getConnection()\n          .select('*')\n          .from(joinTable.name)\n          .whereIn(targetColumnName, oldEntryIds)\n          .transacting(trx);\n\n        if (existingRelations.length > 0) {\n          relationsToUpdate.push({ joinTable, relations: existingRelations });\n        }\n      }\n    }\n  });\n\n  return relationsToUpdate;\n};\n\n/**\n * Synchronizes the order of bidirectional relations after content entries have changed state.\n *\n * When entries change state (e.g., draft → published), their IDs change and all relations are recreated.\n * While the order of relations from the entry's perspective is maintained (as they're created in order),\n * the inverse relations (from related entries' perspective) would all appear last in order since they're new.\n *\n * Example:\n * ```\n * Before publish:\n *   Article(id:1) →(order:1)→ Category(id:5)\n *   Category(id:5) →(order:3)→ Article(id:1)\n *\n * After publish (without sync):\n *   Article(id:2) →(order:1)→ Category(id:5)    [order preserved]\n *   Category(id:5) →(order:99)→ Article(id:2)   [order lost - appears last]\n *\n * After sync:\n *   Article(id:2) →(order:1)→ Category(id:5)    [order preserved]\n *   Category(id:5) →(order:3)→ Article(id:2)    [order restored]\n * ```\n *\n * @param oldEntries - Array of previous entry versions with their IDs and locales\n * @param newEntries - Array of new entry versions with their IDs and locales\n * @param existingRelations - Array of join table data containing the relations to be updated\n */\nconst sync = async (\n  oldEntries: { id: string; locale: string }[],\n  newEntries: { id: string; locale: string }[],\n  existingRelations: { joinTable: any; relations: any[] }[]\n) => {\n  // Group new entries by locale for easier lookup\n  const newEntriesByLocale = keyBy('locale', newEntries);\n\n  // Create a mapping of old entry IDs to new entry IDs based on locale\n  const entryIdMapping = oldEntries.reduce(\n    (acc, oldEntry) => {\n      const newEntry = newEntriesByLocale[oldEntry.locale];\n      if (!newEntry) return acc;\n      acc[oldEntry.id] = newEntry.id;\n      return acc;\n    },\n    {} as Record<string, string>\n  );\n\n  await strapi.db.transaction(async ({ trx }) => {\n    for (const { joinTable, relations } of existingRelations) {\n      const sourceColumn = joinTable.inverseJoinColumn.name;\n      const targetColumn = joinTable.joinColumn.name;\n      const orderColumn = joinTable.orderColumnName;\n\n      // Failsafe in case those don't exist\n      if (!sourceColumn || !targetColumn || !orderColumn) {\n        continue;\n      }\n\n      // Update order values for each relation\n      // TODO: Find a way to batch it more efficiently\n      await async.map(relations, (relation: any) => {\n        const {\n          [sourceColumn]: oldSourceId,\n          [targetColumn]: targetId,\n          [orderColumn]: originalOrder,\n        } = relation;\n\n        // Update the order column for the new relation entry\n        return trx\n          .from(joinTable.name)\n          .where(sourceColumn, entryIdMapping[oldSourceId])\n          .where(targetColumn, targetId)\n          .update({ [orderColumn]: originalOrder });\n      });\n    }\n  });\n};\n\nexport { load, sync };\n"],"names":["load","uid","oldVersions","relationsToUpdate","strapi","db","transaction","trx","contentTypes","Object","values","components","model","dbModel","metadata","get","attribute","attributes","type","target","inversedBy","mappedBy","joinTable","name","targetColumnName","inverseJoinColumn","oldEntryIds","map","entry","id","existingRelations","getConnection","select","from","whereIn","transacting","length","push","relations","sync","oldEntries","newEntries","newEntriesByLocale","keyBy","entryIdMapping","reduce","acc","oldEntry","newEntry","locale","sourceColumn","targetColumn","joinColumn","orderColumn","orderColumnName","async","relation","oldSourceId","targetId","originalOrder","where","update"],"mappings":";;;AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4CC,UACKA,IAAAA,GAAO,OAAOC,GAAAA,EAAsB,EAAEC,WAAW,EAAe,GAAA;AACpE,IAAA,MAAMC,oBAAoB,EAAE;IAE5B,MAAMC,MAAAA,CAAOC,EAAE,CAACC,WAAW,CAAC,OAAO,EAAEC,GAAG,EAAE,GAAA;AACxC,QAAA,MAAMC,YAAAA,GAAeC,MAAAA,CAAOC,MAAM,CAACN,OAAOI,YAAY,CAAA;AACtD,QAAA,MAAMG,UAAAA,GAAaF,MAAAA,CAAOC,MAAM,CAACN,OAAOO,UAAU,CAAA;AAElD,QAAA,KAAK,MAAMC,KAAAA,IAAS;AAAIJ,YAAAA,GAAAA,YAAAA;AAAiBG,YAAAA,GAAAA;SAAW,CAAE;YACpD,MAAME,OAAAA,GAAUT,OAAOC,EAAE,CAACS,QAAQ,CAACC,GAAG,CAACH,KAAAA,CAAMX,GAAG,CAAA;AAEhD,YAAA,KAAK,MAAMe,SAAAA,IAAaP,MAAAA,CAAOC,MAAM,CAACG,OAAAA,CAAQI,UAAU,CAAA,CAAU;;AAEhE,gBAAA,IACED,UAAUE,IAAI,KAAK,UAAA,IACnBF,SAAAA,CAAUG,MAAM,KAAKlB,GAAAA,IACrB,EAAEe,UAAUI,UAAU,IAAIJ,SAAAA,CAAUK,QAAQ,CAAD,EAC3C;AACA,oBAAA;AACF,gBAAA;;;gBAIA,IAAIT,KAAAA,CAAMX,GAAG,KAAKA,GAAAA,EAAK;AACrB,oBAAA;AACF,gBAAA;gBAEA,MAAMqB,SAAAA,GAAYN,UAAUM,SAAS;AACrC,gBAAA,IAAI,CAACA,SAAAA,EAAW;AACd,oBAAA;AACF,gBAAA;AAEA,gBAAA,MAAM,EAAEC,IAAAA,EAAMC,gBAAgB,EAAE,GAAGF,UAAUG,iBAAiB;;AAG9D,gBAAA,MAAMC,cAAcxB,WAAAA,CAAYyB,GAAG,CAAC,CAACC,KAAAA,GAAUA,MAAMC,EAAE,CAAA;gBAEvD,MAAMC,iBAAAA,GAAoB,MAAM1B,MAAAA,CAAOC,EAAE,CACtC0B,aAAa,EAAA,CACbC,MAAM,CAAC,GAAA,CAAA,CACPC,IAAI,CAACX,SAAAA,CAAUC,IAAI,CAAA,CACnBW,OAAO,CAACV,gBAAAA,EAAkBE,WAAAA,CAAAA,CAC1BS,WAAW,CAAC5B,GAAAA,CAAAA;gBAEf,IAAIuB,iBAAAA,CAAkBM,MAAM,GAAG,CAAA,EAAG;AAChCjC,oBAAAA,iBAAAA,CAAkBkC,IAAI,CAAC;AAAEf,wBAAAA,SAAAA;wBAAWgB,SAAAA,EAAWR;AAAkB,qBAAA,CAAA;AACnE,gBAAA;AACF,YAAA;AACF,QAAA;AACF,IAAA,CAAA,CAAA;IAEA,OAAO3B,iBAAAA;AACT;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;AAyBC,IACD,MAAMoC,IAAAA,GAAO,OACXC,UAAAA,EACAC,UAAAA,EACAX,iBAAAA,GAAAA;;IAGA,MAAMY,kBAAAA,GAAqBC,MAAM,QAAA,EAAUF,UAAAA,CAAAA;;AAG3C,IAAA,MAAMG,cAAAA,GAAiBJ,UAAAA,CAAWK,MAAM,CACtC,CAACC,GAAAA,EAAKC,QAAAA,GAAAA;AACJ,QAAA,MAAMC,QAAAA,GAAWN,kBAAkB,CAACK,QAAAA,CAASE,MAAM,CAAC;QACpD,IAAI,CAACD,UAAU,OAAOF,GAAAA;AACtBA,QAAAA,GAAG,CAACC,QAAAA,CAASlB,EAAE,CAAC,GAAGmB,SAASnB,EAAE;QAC9B,OAAOiB,GAAAA;AACT,IAAA,CAAA,EACA,EAAC,CAAA;IAGH,MAAM1C,MAAAA,CAAOC,EAAE,CAACC,WAAW,CAAC,OAAO,EAAEC,GAAG,EAAE,GAAA;AACxC,QAAA,KAAK,MAAM,EAAEe,SAAS,EAAEgB,SAAS,EAAE,IAAIR,iBAAAA,CAAmB;AACxD,YAAA,MAAMoB,YAAAA,GAAe5B,SAAAA,CAAUG,iBAAiB,CAACF,IAAI;AACrD,YAAA,MAAM4B,YAAAA,GAAe7B,SAAAA,CAAU8B,UAAU,CAAC7B,IAAI;YAC9C,MAAM8B,WAAAA,GAAc/B,UAAUgC,eAAe;;AAG7C,YAAA,IAAI,CAACJ,YAAAA,IAAgB,CAACC,YAAAA,IAAgB,CAACE,WAAAA,EAAa;AAClD,gBAAA;AACF,YAAA;;;AAIA,YAAA,MAAME,KAAAA,CAAM5B,GAAG,CAACW,SAAAA,EAAW,CAACkB,QAAAA,GAAAA;AAC1B,gBAAA,MAAM,EACJ,CAACN,YAAAA,GAAeO,WAAW,EAC3B,CAACN,YAAAA,GAAeO,QAAQ,EACxB,CAACL,WAAAA,GAAcM,aAAa,EAC7B,GAAGH,QAAAA;;AAGJ,gBAAA,OAAOjD,IACJ0B,IAAI,CAACX,UAAUC,IAAI,CAAA,CACnBqC,KAAK,CAACV,YAAAA,EAAcN,cAAc,CAACa,YAAY,CAAA,CAC/CG,KAAK,CAACT,YAAAA,EAAcO,QAAAA,CAAAA,CACpBG,MAAM,CAAC;AAAE,oBAAA,CAACR,cAAcM;AAAc,iBAAA,CAAA;AAC3C,YAAA,CAAA,CAAA;AACF,QAAA;AACF,IAAA,CAAA,CAAA;AACF;;;;"}
+{"version":3,"file":"bidirectional-relations.mjs","sources":["../../../../src/services/document-service/utils/bidirectional-relations.ts"],"sourcesContent":["/* eslint-disable no-continue */\nimport { keyBy, omit } from 'lodash/fp';\nimport type { UID, Schema } from '@strapi/types';\nimport type { JoinTable } from '@strapi/database';\n\ninterface LoadContext {\n  oldVersions: { id: string; locale: string }[];\n  newVersions: { id: string; locale: string }[];\n}\n\ninterface RelationEntry {\n  joinTable: JoinTable;\n  relations: Record<string, unknown>[];\n}\n\n/**\n * Loads all bidirectional relations that need to be synchronized when content entries change state\n * (e.g., during publish/unpublish operations).\n *\n * In Strapi, bidirectional relations allow maintaining order from both sides of the relation.\n * When an entry is published, the following occurs:\n *\n * 1. The old published entry is deleted\n * 2. A new entry is created with all its relations\n *\n * This process affects relation ordering in the following way:\n *\n * Initial state (Entry A related to X, Y, Z):\n * ```\n *   Entry A (draft)     Entry A (published)\n *      │                     │\n *      ├──(1)→ X            ├──(1)→ X\n *      ├──(2)→ Y            ├──(2)→ Y\n *      └──(3)→ Z            └──(3)→ Z\n *\n *   X's perspective:         Y's perspective:         Z's perspective:\n *      └──(2)→ Entry A         └──(1)→ Entry A         └──(3)→ Entry A\n * ```\n *\n * After publishing Entry A (without relation order sync):\n * ```\n *   Entry A (draft)     Entry A (new published)\n *      │                     │\n *      ├──(1)→ X            ├──(1)→ X\n *      ├──(2)→ Y            ├──(2)→ Y\n *      └──(3)→ Z            └──(3)→ Z\n *\n *   X's perspective:         Y's perspective:         Z's perspective:\n *      └──(3)→ Entry A         └──(3)→ Entry A         └──(3)→ Entry A\n *                           (all relations appear last in order)\n * ```\n *\n * This module preserves the original ordering from both perspectives by:\n * 1. Capturing the relation order before the entry state changes\n * 2. Restoring this order after the new relations are created\n *\n * @param uid - The unique identifier of the content type being processed\n * @param context - Object containing arrays of old and new entry versions\n * @returns Array of objects containing join table metadata and relations to be updated\n */\nconst load = async (uid: UID.ContentType, { oldVersions }: LoadContext) => {\n  const relationsToUpdate: RelationEntry[] = [];\n\n  await strapi.db.transaction(async ({ trx }) => {\n    const contentTypes = Object.values(strapi.contentTypes) as Schema.ContentType[];\n    const components = Object.values(strapi.components) as Schema.Component[];\n\n    for (const model of [...contentTypes, ...components]) {\n      const dbModel = strapi.db.metadata.get(model.uid);\n\n      for (const attribute of Object.values(dbModel.attributes) as Record<string, any>[]) {\n        // Skip if not a bidirectional relation targeting our content type\n        if (\n          attribute.type !== 'relation' ||\n          attribute.target !== uid ||\n          !(attribute.inversedBy || attribute.mappedBy)\n        ) {\n          continue;\n        }\n\n        // If it's a self referencing relation, there is no need to sync any relation\n        // The order will already be handled as both sides are inside the same content type\n        if (model.uid === uid) {\n          continue;\n        }\n\n        const joinTable = attribute.joinTable;\n        if (!joinTable) {\n          continue;\n        }\n\n        const { name: targetColumnName } = joinTable.inverseJoinColumn;\n\n        // Load all relations that need their order preserved\n        const oldEntryIds = oldVersions.map((entry) => entry.id);\n\n        const existingRelations = await strapi.db\n          .getConnection()\n          .select('*')\n          .from(joinTable.name)\n          .whereIn(targetColumnName, oldEntryIds)\n          .transacting(trx);\n\n        if (existingRelations.length > 0) {\n          relationsToUpdate.push({ joinTable, relations: existingRelations });\n        }\n      }\n    }\n  });\n\n  return relationsToUpdate;\n};\n\n/**\n * Synchronizes the order of bidirectional relations after content entries have changed state.\n *\n * When entries change state (e.g., draft → published), their IDs change and all relations are recreated.\n * While the order of relations from the entry's perspective is maintained (as they're created in order),\n * the inverse relations (from related entries' perspective) would all appear last in order since they're new.\n *\n * Example:\n * ```\n * Before publish:\n *   Article(id:1) →(order:1)→ Category(id:5)\n *   Category(id:5) →(order:3)→ Article(id:1)\n *\n * After publish (without sync):\n *   Article(id:2) →(order:1)→ Category(id:5)    [order preserved]\n *   Category(id:5) →(order:99)→ Article(id:2)   [order lost - appears last]\n *\n * After sync:\n *   Article(id:2) →(order:1)→ Category(id:5)    [order preserved]\n *   Category(id:5) →(order:3)→ Article(id:2)    [order restored]\n * ```\n *\n * @param oldEntries - Array of previous entry versions with their IDs and locales\n * @param newEntries - Array of new entry versions with their IDs and locales\n * @param existingRelations - Array of join table data containing the relations to be updated\n */\nconst sync = async (\n  oldEntries: { id: string; locale: string }[],\n  newEntries: { id: string; locale: string }[],\n  existingRelations: RelationEntry[]\n) => {\n  // Group new entries by locale for easier lookup\n  const newEntriesByLocale = keyBy('locale', newEntries);\n\n  // Create a mapping of old entry IDs to new entry IDs based on locale\n  const entryIdMapping = oldEntries.reduce(\n    (acc, oldEntry) => {\n      const newEntry = newEntriesByLocale[oldEntry.locale];\n      if (!newEntry) return acc;\n      acc[oldEntry.id] = newEntry.id;\n      return acc;\n    },\n    {} as Record<string, string>\n  );\n\n  const republishedEntryIds = new Set(newEntries.map((e) => String(e.id)));\n  const isRepublishedEntry = (id: string | number) => republishedEntryIds.has(String(id));\n\n  await strapi.db.transaction(async ({ trx }) => {\n    for (const { joinTable, relations } of existingRelations) {\n      const sourceColumn = joinTable.inverseJoinColumn.name;\n      const targetColumn = joinTable.joinColumn.name;\n      const orderColumn = joinTable.orderColumnName;\n\n      // Failsafe in case those don't exist\n      if (!sourceColumn || !targetColumn || !orderColumn) {\n        continue;\n      }\n\n      const mappedRelations = relations\n        .map((relation) => ({\n          relation,\n          oldSourceId: relation[sourceColumn] as string,\n          targetId: relation[targetColumn] as string,\n          originalOrder: relation[orderColumn],\n          newSourceId: entryIdMapping[relation[sourceColumn] as string],\n        }))\n        .filter((r): r is typeof r & { newSourceId: string } => Boolean(r.newSourceId));\n\n      if (!mappedRelations.length) continue;\n\n      const newSourceIds = mappedRelations.map((r) => r.newSourceId);\n\n      // Batch UPDATE: set each row's order in a single statement using CASE\n      const caseFragments = mappedRelations.map(() => `WHEN ?? = ? AND ?? = ? THEN ?`);\n      const caseBindings = mappedRelations.flatMap(({ newSourceId, targetId, originalOrder }) => [\n        sourceColumn,\n        newSourceId,\n        targetColumn,\n        targetId,\n        originalOrder,\n      ]);\n\n      await trx(joinTable.name)\n        .whereIn(sourceColumn, newSourceIds)\n        .update({\n          [orderColumn]: trx.raw(`CASE ${caseFragments.join(' ')} ELSE ?? END`, [\n            ...caseBindings,\n            orderColumn,\n          ]),\n        });\n\n      // Batch SELECT: find which rows exist so we know what to insert\n      const existingRows = await trx(joinTable.name)\n        .whereIn(sourceColumn, newSourceIds)\n        .select(sourceColumn, targetColumn);\n\n      const existingSet = new Set(\n        existingRows.map((r: Record<string, unknown>) => `${r[sourceColumn]}:${r[targetColumn]}`)\n      );\n\n      // Batch INSERT: insert cascade-deleted rows that aren't from republished sources\n      const toInsert = mappedRelations\n        .filter(\n          ({ newSourceId, targetId }) =>\n            !existingSet.has(`${newSourceId}:${targetId}`) && !isRepublishedEntry(newSourceId)\n        )\n        .map(({ relation, newSourceId, originalOrder }) => ({\n          ...omit(strapi.db.metadata.identifiers.ID_COLUMN, relation),\n          [sourceColumn]: newSourceId,\n          [orderColumn]: originalOrder,\n        }));\n\n      if (toInsert.length) {\n        await trx.batchInsert(joinTable.name, toInsert, 1000);\n      }\n    }\n  });\n};\n\nexport { load, sync };\n"],"names":["load","uid","oldVersions","relationsToUpdate","strapi","db","transaction","trx","contentTypes","Object","values","components","model","dbModel","metadata","get","attribute","attributes","type","target","inversedBy","mappedBy","joinTable","name","targetColumnName","inverseJoinColumn","oldEntryIds","map","entry","id","existingRelations","getConnection","select","from","whereIn","transacting","length","push","relations","sync","oldEntries","newEntries","newEntriesByLocale","keyBy","entryIdMapping","reduce","acc","oldEntry","newEntry","locale","republishedEntryIds","Set","e","String","isRepublishedEntry","has","sourceColumn","targetColumn","joinColumn","orderColumn","orderColumnName","mappedRelations","relation","oldSourceId","targetId","originalOrder","newSourceId","filter","r","Boolean","newSourceIds","caseFragments","caseBindings","flatMap","update","raw","join","existingRows","existingSet","toInsert","omit","identifiers","ID_COLUMN","batchInsert"],"mappings":"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"}

package/dist/services/document-service/utils/unidirectional-relations.js

@@ -120,8 +120,8 @@ var fp = require('lodash/fp');
                     [column]: newId
                 };
             });
-            // Insert those relations into the join table
-            await trx.batchInsert(joinTable.name, newRelations, 1000);
+            const batchSize = strapi.db.dialect.getBatchInsertSize();
+            await trx.batchInsert(joinTable.name, newRelations, batchSize);
         }
     });
 };

package/dist/services/document-service/utils/unidirectional-relations.js.map

@@ -1 +1 @@
-{"version":3,"file":"unidirectional-relations.js","sources":["../../../../src/services/document-service/utils/unidirectional-relations.ts"],"sourcesContent":["/* eslint-disable no-continue */\nimport { keyBy, omit } from 'lodash/fp';\n\nimport type { UID, Schema } from '@strapi/types';\n\nimport type { JoinTable } from '@strapi/database';\n\ninterface LoadContext {\n  oldVersions: { id: string; locale: string }[];\n  newVersions: { id: string; locale: string }[];\n}\n\ninterface RelationUpdate {\n  joinTable: JoinTable;\n  relations: Record<string, any>[];\n}\n\ninterface RelationFilterOptions {\n  /**\n   * Function to determine if a relation should be propagated to new document versions\n   * This replaces the hardcoded component-specific logic\n   */\n  shouldPropagateRelation?: (\n    relation: Record<string, any>,\n    model: Schema.Component | Schema.ContentType,\n    trx: any\n  ) => Promise<boolean>;\n}\n\n/**\n * Loads lingering relations that need to be updated when overriding a published or draft entry.\n * This is necessary because the relations are uni-directional and the target entry is not aware of the source entry.\n * This is not the case for bi-directional relations, where the target entry is also linked to the source entry.\n */\nconst load = async (\n  uid: UID.ContentType,\n  { oldVersions, newVersions }: LoadContext,\n  options: RelationFilterOptions = {}\n): Promise<RelationUpdate[]> => {\n  const updates: RelationUpdate[] = [];\n\n  // Iterate all components and content types to find relations that need to be updated\n  await strapi.db.transaction(async ({ trx }) => {\n    const contentTypes = Object.values(strapi.contentTypes) as Schema.ContentType[];\n    const components = Object.values(strapi.components) as Schema.Component[];\n\n    for (const model of [...contentTypes, ...components]) {\n      const dbModel = strapi.db.metadata.get(model.uid);\n\n      for (const attribute of Object.values(dbModel.attributes) as any) {\n        /**\n         * Only consider unidirectional relations\n         */\n        if (\n          attribute.type !== 'relation' ||\n          attribute.target !== uid ||\n          attribute.inversedBy ||\n          attribute.mappedBy\n        ) {\n          continue;\n        }\n\n        // TODO: joinColumn relations\n        const joinTable = attribute.joinTable;\n        if (!joinTable) {\n          continue;\n        }\n\n        const { name: sourceColumnName } = joinTable.joinColumn;\n        const { name: targetColumnName } = joinTable.inverseJoinColumn;\n\n        /**\n         * Load all relations that need to be updated\n         */\n        // NOTE: when the model has draft and publish, we can assume relation are only draft to draft & published to published\n        const ids = oldVersions.map((entry) => entry.id);\n\n        const oldVersionsRelations = await strapi.db\n          .getConnection()\n          .select('*')\n          .from(joinTable.name)\n          .whereIn(targetColumnName, ids)\n          .transacting(trx);\n\n        if (oldVersionsRelations.length > 0) {\n          updates.push({ joinTable, relations: oldVersionsRelations });\n        }\n\n        /**\n         * if publishing\n         *  if published version exists\n         *    updated published versions links\n         *  else\n         *    create link to newly published version\n         *\n         * if discarding\n         *    if published version link exists & not draft version link\n         *       create link to new draft version\n         */\n        if (!model.options?.draftAndPublish) {\n          const ids = newVersions.map((entry) => entry.id);\n\n          // This is the step were we query the join table based on the id of the document\n          const newVersionsRelations = await strapi.db\n            .getConnection()\n            .select('*')\n            .from(joinTable.name)\n            .whereIn(targetColumnName, ids)\n            .transacting(trx);\n\n          let versionRelations = newVersionsRelations;\n          if (options.shouldPropagateRelation) {\n            const relationsToPropagate = [];\n            for (const relation of newVersionsRelations) {\n              if (await options.shouldPropagateRelation(relation, model, trx)) {\n                relationsToPropagate.push(relation);\n              }\n            }\n            versionRelations = relationsToPropagate;\n          }\n\n          if (versionRelations.length > 0) {\n            // when publishing a draft that doesn't have a published version yet,\n            // copy the links to the draft over to the published version\n            // when discarding a published version, if no drafts exists\n            const discardToAdd = versionRelations\n              .filter((relation) => {\n                const matchingOldVersion = oldVersionsRelations.find((oldRelation) => {\n                  return oldRelation[sourceColumnName] === relation[sourceColumnName];\n                });\n\n                return !matchingOldVersion;\n              })\n              .map(omit(strapi.db.metadata.identifiers.ID_COLUMN));\n\n            updates.push({ joinTable, relations: discardToAdd });\n          }\n        }\n      }\n    }\n  });\n\n  return updates;\n};\n\n/**\n * Updates uni directional relations to target the right entries when overriding published or draft entries.\n *\n * This function:\n * 1. Creates new relations pointing to the new entry versions\n * 2. Precisely deletes only the old relations being replaced to prevent orphaned links\n *\n * @param oldEntries The old entries that are being overridden\n * @param newEntries The new entries that are overriding the old ones\n * @param oldRelations The relations that were previously loaded with `load` @see load\n */\nconst sync = async (\n  oldEntries: { id: string; locale: string }[],\n  newEntries: { id: string; locale: string }[],\n  oldRelations: { joinTable: any; relations: any[] }[]\n) => {\n  /**\n   * Create a map of old entry ids to new entry ids\n   *\n   * Will be used to update the relation target ids\n   */\n  const newEntryByLocale = keyBy('locale', newEntries);\n  const oldEntriesMap = oldEntries.reduce(\n    (acc, entry) => {\n      const newEntry = newEntryByLocale[entry.locale];\n      if (!newEntry) return acc;\n      acc[entry.id] = newEntry.id;\n      return acc;\n    },\n    {} as Record<string, string>\n  );\n\n  await strapi.db.transaction(async ({ trx }) => {\n    // Iterate old relations that are deleted and insert the new ones\n    for (const { joinTable, relations } of oldRelations) {\n      // Update old ids with the new ones\n      const column = joinTable.inverseJoinColumn.name;\n\n      const newRelations = relations.map((relation) => {\n        const newId = oldEntriesMap[relation[column]];\n        return { ...relation, [column]: newId };\n      });\n\n      // Insert those relations into the join table\n      await trx.batchInsert(joinTable.name, newRelations, 1000);\n    }\n  });\n};\n\nexport { load, sync };\nexport type { RelationFilterOptions };\n"],"names":["load","uid","oldVersions","newVersions","options","updates","strapi","db","transaction","trx","contentTypes","Object","values","components","model","dbModel","metadata","get","attribute","attributes","type","target","inversedBy","mappedBy","joinTable","name","sourceColumnName","joinColumn","targetColumnName","inverseJoinColumn","ids","map","entry","id","oldVersionsRelations","getConnection","select","from","whereIn","transacting","length","push","relations","draftAndPublish","newVersionsRelations","versionRelations","shouldPropagateRelation","relationsToPropagate","relation","discardToAdd","filter","matchingOldVersion","find","oldRelation","omit","identifiers","ID_COLUMN","sync","oldEntries","newEntries","oldRelations","newEntryByLocale","keyBy","oldEntriesMap","reduce","acc","newEntry","locale","column","newRelations","newId","batchInsert"],"mappings":"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"}
+{"version":3,"file":"unidirectional-relations.js","sources":["../../../../src/services/document-service/utils/unidirectional-relations.ts"],"sourcesContent":["/* eslint-disable no-continue */\nimport { keyBy, omit } from 'lodash/fp';\n\nimport type { UID, Schema } from '@strapi/types';\n\nimport type { JoinTable } from '@strapi/database';\n\ninterface LoadContext {\n  oldVersions: { id: string; locale: string }[];\n  newVersions: { id: string; locale: string }[];\n}\n\ninterface RelationUpdate {\n  joinTable: JoinTable;\n  relations: Record<string, any>[];\n}\n\ninterface RelationFilterOptions {\n  /**\n   * Function to determine if a relation should be propagated to new document versions\n   * This replaces the hardcoded component-specific logic\n   */\n  shouldPropagateRelation?: (\n    relation: Record<string, any>,\n    model: Schema.Component | Schema.ContentType,\n    trx: any\n  ) => Promise<boolean>;\n}\n\n/**\n * Loads lingering relations that need to be updated when overriding a published or draft entry.\n * This is necessary because the relations are uni-directional and the target entry is not aware of the source entry.\n * This is not the case for bi-directional relations, where the target entry is also linked to the source entry.\n */\nconst load = async (\n  uid: UID.ContentType,\n  { oldVersions, newVersions }: LoadContext,\n  options: RelationFilterOptions = {}\n): Promise<RelationUpdate[]> => {\n  const updates: RelationUpdate[] = [];\n\n  // Iterate all components and content types to find relations that need to be updated\n  await strapi.db.transaction(async ({ trx }) => {\n    const contentTypes = Object.values(strapi.contentTypes) as Schema.ContentType[];\n    const components = Object.values(strapi.components) as Schema.Component[];\n\n    for (const model of [...contentTypes, ...components]) {\n      const dbModel = strapi.db.metadata.get(model.uid);\n\n      for (const attribute of Object.values(dbModel.attributes) as any) {\n        /**\n         * Only consider unidirectional relations\n         */\n        if (\n          attribute.type !== 'relation' ||\n          attribute.target !== uid ||\n          attribute.inversedBy ||\n          attribute.mappedBy\n        ) {\n          continue;\n        }\n\n        // TODO: joinColumn relations\n        const joinTable = attribute.joinTable;\n        if (!joinTable) {\n          continue;\n        }\n\n        const { name: sourceColumnName } = joinTable.joinColumn;\n        const { name: targetColumnName } = joinTable.inverseJoinColumn;\n\n        /**\n         * Load all relations that need to be updated\n         */\n        // NOTE: when the model has draft and publish, we can assume relation are only draft to draft & published to published\n        const ids = oldVersions.map((entry) => entry.id);\n\n        const oldVersionsRelations = await strapi.db\n          .getConnection()\n          .select('*')\n          .from(joinTable.name)\n          .whereIn(targetColumnName, ids)\n          .transacting(trx);\n\n        if (oldVersionsRelations.length > 0) {\n          updates.push({ joinTable, relations: oldVersionsRelations });\n        }\n\n        /**\n         * if publishing\n         *  if published version exists\n         *    updated published versions links\n         *  else\n         *    create link to newly published version\n         *\n         * if discarding\n         *    if published version link exists & not draft version link\n         *       create link to new draft version\n         */\n        if (!model.options?.draftAndPublish) {\n          const ids = newVersions.map((entry) => entry.id);\n\n          // This is the step were we query the join table based on the id of the document\n          const newVersionsRelations = await strapi.db\n            .getConnection()\n            .select('*')\n            .from(joinTable.name)\n            .whereIn(targetColumnName, ids)\n            .transacting(trx);\n\n          let versionRelations = newVersionsRelations;\n          if (options.shouldPropagateRelation) {\n            const relationsToPropagate = [];\n            for (const relation of newVersionsRelations) {\n              if (await options.shouldPropagateRelation(relation, model, trx)) {\n                relationsToPropagate.push(relation);\n              }\n            }\n            versionRelations = relationsToPropagate;\n          }\n\n          if (versionRelations.length > 0) {\n            // when publishing a draft that doesn't have a published version yet,\n            // copy the links to the draft over to the published version\n            // when discarding a published version, if no drafts exists\n            const discardToAdd = versionRelations\n              .filter((relation) => {\n                const matchingOldVersion = oldVersionsRelations.find((oldRelation) => {\n                  return oldRelation[sourceColumnName] === relation[sourceColumnName];\n                });\n\n                return !matchingOldVersion;\n              })\n              .map(omit(strapi.db.metadata.identifiers.ID_COLUMN));\n\n            updates.push({ joinTable, relations: discardToAdd });\n          }\n        }\n      }\n    }\n  });\n\n  return updates;\n};\n\n/**\n * Updates uni directional relations to target the right entries when overriding published or draft entries.\n *\n * This function:\n * 1. Creates new relations pointing to the new entry versions\n * 2. Precisely deletes only the old relations being replaced to prevent orphaned links\n *\n * @param oldEntries The old entries that are being overridden\n * @param newEntries The new entries that are overriding the old ones\n * @param oldRelations The relations that were previously loaded with `load` @see load\n */\nconst sync = async (\n  oldEntries: { id: string; locale: string }[],\n  newEntries: { id: string; locale: string }[],\n  oldRelations: { joinTable: any; relations: any[] }[]\n) => {\n  /**\n   * Create a map of old entry ids to new entry ids\n   *\n   * Will be used to update the relation target ids\n   */\n  const newEntryByLocale = keyBy('locale', newEntries);\n  const oldEntriesMap = oldEntries.reduce(\n    (acc, entry) => {\n      const newEntry = newEntryByLocale[entry.locale];\n      if (!newEntry) return acc;\n      acc[entry.id] = newEntry.id;\n      return acc;\n    },\n    {} as Record<string, string>\n  );\n\n  await strapi.db.transaction(async ({ trx }) => {\n    // Iterate old relations that are deleted and insert the new ones\n    for (const { joinTable, relations } of oldRelations) {\n      // Update old ids with the new ones\n      const column = joinTable.inverseJoinColumn.name;\n\n      const newRelations = relations.map((relation) => {\n        const newId = oldEntriesMap[relation[column]];\n        return { ...relation, [column]: newId };\n      });\n\n      const batchSize = strapi.db.dialect.getBatchInsertSize();\n      await trx.batchInsert(joinTable.name, newRelations, batchSize);\n    }\n  });\n};\n\nexport { load, sync };\nexport type { RelationFilterOptions };\n"],"names":["load","uid","oldVersions","newVersions","options","updates","strapi","db","transaction","trx","contentTypes","Object","values","components","model","dbModel","metadata","get","attribute","attributes","type","target","inversedBy","mappedBy","joinTable","name","sourceColumnName","joinColumn","targetColumnName","inverseJoinColumn","ids","map","entry","id","oldVersionsRelations","getConnection","select","from","whereIn","transacting","length","push","relations","draftAndPublish","newVersionsRelations","versionRelations","shouldPropagateRelation","relationsToPropagate","relation","discardToAdd","filter","matchingOldVersion","find","oldRelation","omit","identifiers","ID_COLUMN","sync","oldEntries","newEntries","oldRelations","newEntryByLocale","keyBy","oldEntriesMap","reduce","acc","newEntry","locale","column","newRelations","newId","batchSize","dialect","getBatchInsertSize","batchInsert"],"mappings":";;;;AA6BA;;;;AAIC,IACD,MAAMA,IAAAA,GAAO,OACXC,GAAAA,EACA,EAAEC,WAAW,EAAEC,WAAW,EAAe,EACzCC,OAAAA,GAAiC,EAAE,GAAA;AAEnC,IAAA,MAAMC,UAA4B,EAAE;;IAGpC,MAAMC,MAAAA,CAAOC,EAAE,CAACC,WAAW,CAAC,OAAO,EAAEC,GAAG,EAAE,GAAA;AACxC,QAAA,MAAMC,YAAAA,GAAeC,MAAAA,CAAOC,MAAM,CAACN,OAAOI,YAAY,CAAA;AACtD,QAAA,MAAMG,UAAAA,GAAaF,MAAAA,CAAOC,MAAM,CAACN,OAAOO,UAAU,CAAA;AAElD,QAAA,KAAK,MAAMC,KAAAA,IAAS;AAAIJ,YAAAA,GAAAA,YAAAA;AAAiBG,YAAAA,GAAAA;SAAW,CAAE;YACpD,MAAME,OAAAA,GAAUT,OAAOC,EAAE,CAACS,QAAQ,CAACC,GAAG,CAACH,KAAAA,CAAMb,GAAG,CAAA;AAEhD,YAAA,KAAK,MAAMiB,SAAAA,IAAaP,MAAAA,CAAOC,MAAM,CAACG,OAAAA,CAAQI,UAAU,CAAA,CAAU;AAChE;;AAEC,YACD,IACED,SAAAA,CAAUE,IAAI,KAAK,cACnBF,SAAAA,CAAUG,MAAM,KAAKpB,GAAAA,IACrBiB,SAAAA,CAAUI,UAAU,IACpBJ,SAAAA,CAAUK,QAAQ,EAClB;AACA,oBAAA;AACF,gBAAA;;gBAGA,MAAMC,SAAAA,GAAYN,UAAUM,SAAS;AACrC,gBAAA,IAAI,CAACA,SAAAA,EAAW;AACd,oBAAA;AACF,gBAAA;AAEA,gBAAA,MAAM,EAAEC,IAAAA,EAAMC,gBAAgB,EAAE,GAAGF,UAAUG,UAAU;AACvD,gBAAA,MAAM,EAAEF,IAAAA,EAAMG,gBAAgB,EAAE,GAAGJ,UAAUK,iBAAiB;AAE9D;;AAEC;AAED,gBAAA,MAAMC,MAAM5B,WAAAA,CAAY6B,GAAG,CAAC,CAACC,KAAAA,GAAUA,MAAMC,EAAE,CAAA;gBAE/C,MAAMC,oBAAAA,GAAuB,MAAM5B,MAAAA,CAAOC,EAAE,CACzC4B,aAAa,EAAA,CACbC,MAAM,CAAC,GAAA,CAAA,CACPC,IAAI,CAACb,SAAAA,CAAUC,IAAI,CAAA,CACnBa,OAAO,CAACV,gBAAAA,EAAkBE,GAAAA,CAAAA,CAC1BS,WAAW,CAAC9B,GAAAA,CAAAA;gBAEf,IAAIyB,oBAAAA,CAAqBM,MAAM,GAAG,CAAA,EAAG;AACnCnC,oBAAAA,OAAAA,CAAQoC,IAAI,CAAC;AAAEjB,wBAAAA,SAAAA;wBAAWkB,SAAAA,EAAWR;AAAqB,qBAAA,CAAA;AAC5D,gBAAA;AAEA;;;;;;;;;;AAUC,YACD,IAAI,CAACpB,KAAAA,CAAMV,OAAO,EAAEuC,eAAAA,EAAiB;AACnC,oBAAA,MAAMb,MAAM3B,WAAAA,CAAY4B,GAAG,CAAC,CAACC,KAAAA,GAAUA,MAAMC,EAAE,CAAA;;oBAG/C,MAAMW,oBAAAA,GAAuB,MAAMtC,MAAAA,CAAOC,EAAE,CACzC4B,aAAa,EAAA,CACbC,MAAM,CAAC,GAAA,CAAA,CACPC,IAAI,CAACb,SAAAA,CAAUC,IAAI,CAAA,CACnBa,OAAO,CAACV,gBAAAA,EAAkBE,GAAAA,CAAAA,CAC1BS,WAAW,CAAC9B,GAAAA,CAAAA;AAEf,oBAAA,IAAIoC,gBAAAA,GAAmBD,oBAAAA;oBACvB,IAAIxC,OAAAA,CAAQ0C,uBAAuB,EAAE;AACnC,wBAAA,MAAMC,uBAAuB,EAAE;wBAC/B,KAAK,MAAMC,YAAYJ,oBAAAA,CAAsB;AAC3C,4BAAA,IAAI,MAAMxC,OAAAA,CAAQ0C,uBAAuB,CAACE,QAAAA,EAAUlC,OAAOL,GAAAA,CAAAA,EAAM;AAC/DsC,gCAAAA,oBAAAA,CAAqBN,IAAI,CAACO,QAAAA,CAAAA;AAC5B,4BAAA;AACF,wBAAA;wBACAH,gBAAAA,GAAmBE,oBAAAA;AACrB,oBAAA;oBAEA,IAAIF,gBAAAA,CAAiBL,MAAM,GAAG,CAAA,EAAG;;;;AAI/B,wBAAA,MAAMS,YAAAA,GAAeJ,gBAAAA,CAClBK,MAAM,CAAC,CAACF,QAAAA,GAAAA;AACP,4BAAA,MAAMG,kBAAAA,GAAqBjB,oBAAAA,CAAqBkB,IAAI,CAAC,CAACC,WAAAA,GAAAA;AACpD,gCAAA,OAAOA,WAAW,CAAC3B,gBAAAA,CAAiB,KAAKsB,QAAQ,CAACtB,gBAAAA,CAAiB;AACrE,4BAAA,CAAA,CAAA;AAEA,4BAAA,OAAO,CAACyB,kBAAAA;wBACV,CAAA,CAAA,CACCpB,GAAG,CAACuB,OAAAA,CAAKhD,MAAAA,CAAOC,EAAE,CAACS,QAAQ,CAACuC,WAAW,CAACC,SAAS,CAAA,CAAA;AAEpDnD,wBAAAA,OAAAA,CAAQoC,IAAI,CAAC;AAAEjB,4BAAAA,SAAAA;4BAAWkB,SAAAA,EAAWO;AAAa,yBAAA,CAAA;AACpD,oBAAA;AACF,gBAAA;AACF,YAAA;AACF,QAAA;AACF,IAAA,CAAA,CAAA;IAEA,OAAO5C,OAAAA;AACT;AAEA;;;;;;;;;;AAUC,IACD,MAAMoD,IAAAA,GAAO,OACXC,UAAAA,EACAC,UAAAA,EACAC,YAAAA,GAAAA;AAEA;;;;MAKA,MAAMC,gBAAAA,GAAmBC,QAAAA,CAAM,QAAA,EAAUH,UAAAA,CAAAA;AACzC,IAAA,MAAMI,aAAAA,GAAgBL,UAAAA,CAAWM,MAAM,CACrC,CAACC,GAAAA,EAAKjC,KAAAA,GAAAA;AACJ,QAAA,MAAMkC,QAAAA,GAAWL,gBAAgB,CAAC7B,KAAAA,CAAMmC,MAAM,CAAC;QAC/C,IAAI,CAACD,UAAU,OAAOD,GAAAA;AACtBA,QAAAA,GAAG,CAACjC,KAAAA,CAAMC,EAAE,CAAC,GAAGiC,SAASjC,EAAE;QAC3B,OAAOgC,GAAAA;AACT,IAAA,CAAA,EACA,EAAC,CAAA;IAGH,MAAM3D,MAAAA,CAAOC,EAAE,CAACC,WAAW,CAAC,OAAO,EAAEC,GAAG,EAAE,GAAA;;AAExC,QAAA,KAAK,MAAM,EAAEe,SAAS,EAAEkB,SAAS,EAAE,IAAIkB,YAAAA,CAAc;;AAEnD,YAAA,MAAMQ,MAAAA,GAAS5C,SAAAA,CAAUK,iBAAiB,CAACJ,IAAI;AAE/C,YAAA,MAAM4C,YAAAA,GAAe3B,SAAAA,CAAUX,GAAG,CAAC,CAACiB,QAAAA,GAAAA;AAClC,gBAAA,MAAMsB,QAAQP,aAAa,CAACf,QAAQ,CAACoB,OAAO,CAAC;gBAC7C,OAAO;AAAE,oBAAA,GAAGpB,QAAQ;AAAE,oBAAA,CAACoB,SAASE;AAAM,iBAAA;AACxC,YAAA,CAAA,CAAA;AAEA,YAAA,MAAMC,YAAYjE,MAAAA,CAAOC,EAAE,CAACiE,OAAO,CAACC,kBAAkB,EAAA;AACtD,YAAA,MAAMhE,IAAIiE,WAAW,CAAClD,SAAAA,CAAUC,IAAI,EAAE4C,YAAAA,EAAcE,SAAAA,CAAAA;AACtD,QAAA;AACF,IAAA,CAAA,CAAA;AACF;;;;;"}

package/dist/services/document-service/utils/unidirectional-relations.mjs

@@ -118,8 +118,8 @@ import { omit, keyBy } from 'lodash/fp';
                     [column]: newId
                 };
             });
-            // Insert those relations into the join table
-            await trx.batchInsert(joinTable.name, newRelations, 1000);
+            const batchSize = strapi.db.dialect.getBatchInsertSize();
+            await trx.batchInsert(joinTable.name, newRelations, batchSize);
         }
     });
 };