@strapi/core 0.0.0-experimental.a407f3bc8fb79a53cf7975140864526b6ddbac4b → 0.0.0-experimental.a412d03e447a6b755ceffc83d8a71631c0f4f25c

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

@@ -0,0 +1,148 @@
+'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
+ * (e.g., during publish/unpublish operations).
+ *
+ * In Strapi, bidirectional relations allow maintaining order from both sides of the relation.
+ * When an entry is published, the following occurs:
+ *
+ * 1. The old published entry is deleted
+ * 2. A new entry is created with all its relations
+ *
+ * This process affects relation ordering in the following way:
+ *
+ * Initial state (Entry A related to X, Y, Z):
+ * ```
+ *   Entry A (draft)     Entry A (published)
+ *      │                     │
+ *      ├──(1)→ X            ├──(1)→ X
+ *      ├──(2)→ Y            ├──(2)→ Y
+ *      └──(3)→ Z            └──(3)→ Z
+ *
+ *   X's perspective:         Y's perspective:         Z's perspective:
+ *      └──(2)→ Entry A         └──(1)→ Entry A         └──(3)→ Entry A
+ * ```
+ *
+ * After publishing Entry A (without relation order sync):
+ * ```
+ *   Entry A (draft)     Entry A (new published)
+ *      │                     │
+ *      ├──(1)→ X            ├──(1)→ X
+ *      ├──(2)→ Y            ├──(2)→ Y
+ *      └──(3)→ Z            └──(3)→ Z
+ *
+ *   X's perspective:         Y's perspective:         Z's perspective:
+ *      └──(3)→ Entry A         └──(3)→ Entry A         └──(3)→ Entry A
+ *                           (all relations appear last in order)
+ * ```
+ *
+ * This module preserves the original ordering from both perspectives by:
+ * 1. Capturing the relation order before the entry state changes
+ * 2. Restoring this order after the new relations are created
+ *
+ * @param uid - The unique identifier of the content type being processed
+ * @param context - Object containing arrays of old and new entry versions
+ * @returns Array of objects containing join table metadata and relations to be updated
+ */ const load = async (uid, { oldVersions })=>{
+    const relationsToUpdate = [];
+    await strapi.db.transaction(async ({ trx })=>{
+        const contentTypes = Object.values(strapi.contentTypes);
+        const components = Object.values(strapi.components);
+        for (const model of [
+            ...contentTypes,
+            ...components
+        ]){
+            const dbModel = strapi.db.metadata.get(model.uid);
+            for (const attribute of Object.values(dbModel.attributes)){
+                // Skip if not a bidirectional relation targeting our content type
+                if (attribute.type !== 'relation' || attribute.target !== uid || !(attribute.inversedBy || attribute.mappedBy)) {
+                    continue;
+                }
+                // If it's a self referencing relation, there is no need to sync any relation
+                // The order will already be handled as both sides are inside the same content type
+                if (model.uid === uid) {
+                    continue;
+                }
+                const joinTable = attribute.joinTable;
+                if (!joinTable) {
+                    continue;
+                }
+                const { name: targetColumnName } = joinTable.inverseJoinColumn;
+                // Load all relations that need their order preserved
+                const oldEntryIds = oldVersions.map((entry)=>entry.id);
+                const existingRelations = await strapi.db.getConnection().select('*').from(joinTable.name).whereIn(targetColumnName, oldEntryIds).transacting(trx);
+                if (existingRelations.length > 0) {
+                    relationsToUpdate.push({
+                        joinTable,
+                        relations: existingRelations
+                    });
+                }
+            }
+        }
+    });
+    return relationsToUpdate;
+};
+/**
+ * Synchronizes the order of bidirectional relations after content entries have changed state.
+ *
+ * When entries change state (e.g., draft → published), their IDs change and all relations are recreated.
+ * While the order of relations from the entry's perspective is maintained (as they're created in order),
+ * the inverse relations (from related entries' perspective) would all appear last in order since they're new.
+ *
+ * Example:
+ * ```
+ * Before publish:
+ *   Article(id:1) →(order:1)→ Category(id:5)
+ *   Category(id:5) →(order:3)→ Article(id:1)
+ *
+ * After publish (without sync):
+ *   Article(id:2) →(order:1)→ Category(id:5)    [order preserved]
+ *   Category(id:5) →(order:99)→ Article(id:2)   [order lost - appears last]
+ *
+ * After sync:
+ *   Article(id:2) →(order:1)→ Category(id:5)    [order preserved]
+ *   Category(id:5) →(order:3)→ Article(id:2)    [order restored]
+ * ```
+ *
+ * @param oldEntries - Array of previous entry versions with their IDs and locales
+ * @param newEntries - Array of new entry versions with their IDs and locales
+ * @param existingRelations - Array of join table data containing the relations to be updated
+ */ const sync = async (oldEntries, newEntries, existingRelations)=>{
+    // Group new entries by locale for easier lookup
+    const newEntriesByLocale = fp.keyBy('locale', newEntries);
+    // Create a mapping of old entry IDs to new entry IDs based on locale
+    const entryIdMapping = oldEntries.reduce((acc, oldEntry)=>{
+        const newEntry = newEntriesByLocale[oldEntry.locale];
+        if (!newEntry) return acc;
+        acc[oldEntry.id] = newEntry.id;
+        return acc;
+    }, {});
+    await strapi.db.transaction(async ({ trx })=>{
+        for (const { joinTable, relations } of existingRelations){
+            const sourceColumn = joinTable.inverseJoinColumn.name;
+            const targetColumn = joinTable.joinColumn.name;
+            const orderColumn = joinTable.orderColumnName;
+            // Failsafe in case those don't exist
+            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
+                });
+            });
+        }
+    });
+};
+
+exports.load = load;
+exports.sync = sync;
+//# sourceMappingURL=bidirectional-relations.js.map

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

@@ -0,0 +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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"}

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

@@ -0,0 +1,145 @@
+import { keyBy } from 'lodash/fp';
+import { async } from '@strapi/utils';
+
+/**
+ * Loads all bidirectional relations that need to be synchronized when content entries change state
+ * (e.g., during publish/unpublish operations).
+ *
+ * In Strapi, bidirectional relations allow maintaining order from both sides of the relation.
+ * When an entry is published, the following occurs:
+ *
+ * 1. The old published entry is deleted
+ * 2. A new entry is created with all its relations
+ *
+ * This process affects relation ordering in the following way:
+ *
+ * Initial state (Entry A related to X, Y, Z):
+ * ```
+ *   Entry A (draft)     Entry A (published)
+ *      │                     │
+ *      ├──(1)→ X            ├──(1)→ X
+ *      ├──(2)→ Y            ├──(2)→ Y
+ *      └──(3)→ Z            └──(3)→ Z
+ *
+ *   X's perspective:         Y's perspective:         Z's perspective:
+ *      └──(2)→ Entry A         └──(1)→ Entry A         └──(3)→ Entry A
+ * ```
+ *
+ * After publishing Entry A (without relation order sync):
+ * ```
+ *   Entry A (draft)     Entry A (new published)
+ *      │                     │
+ *      ├──(1)→ X            ├──(1)→ X
+ *      ├──(2)→ Y            ├──(2)→ Y
+ *      └──(3)→ Z            └──(3)→ Z
+ *
+ *   X's perspective:         Y's perspective:         Z's perspective:
+ *      └──(3)→ Entry A         └──(3)→ Entry A         └──(3)→ Entry A
+ *                           (all relations appear last in order)
+ * ```
+ *
+ * This module preserves the original ordering from both perspectives by:
+ * 1. Capturing the relation order before the entry state changes
+ * 2. Restoring this order after the new relations are created
+ *
+ * @param uid - The unique identifier of the content type being processed
+ * @param context - Object containing arrays of old and new entry versions
+ * @returns Array of objects containing join table metadata and relations to be updated
+ */ const load = async (uid, { oldVersions })=>{
+    const relationsToUpdate = [];
+    await strapi.db.transaction(async ({ trx })=>{
+        const contentTypes = Object.values(strapi.contentTypes);
+        const components = Object.values(strapi.components);
+        for (const model of [
+            ...contentTypes,
+            ...components
+        ]){
+            const dbModel = strapi.db.metadata.get(model.uid);
+            for (const attribute of Object.values(dbModel.attributes)){
+                // Skip if not a bidirectional relation targeting our content type
+                if (attribute.type !== 'relation' || attribute.target !== uid || !(attribute.inversedBy || attribute.mappedBy)) {
+                    continue;
+                }
+                // If it's a self referencing relation, there is no need to sync any relation
+                // The order will already be handled as both sides are inside the same content type
+                if (model.uid === uid) {
+                    continue;
+                }
+                const joinTable = attribute.joinTable;
+                if (!joinTable) {
+                    continue;
+                }
+                const { name: targetColumnName } = joinTable.inverseJoinColumn;
+                // Load all relations that need their order preserved
+                const oldEntryIds = oldVersions.map((entry)=>entry.id);
+                const existingRelations = await strapi.db.getConnection().select('*').from(joinTable.name).whereIn(targetColumnName, oldEntryIds).transacting(trx);
+                if (existingRelations.length > 0) {
+                    relationsToUpdate.push({
+                        joinTable,
+                        relations: existingRelations
+                    });
+                }
+            }
+        }
+    });
+    return relationsToUpdate;
+};
+/**
+ * Synchronizes the order of bidirectional relations after content entries have changed state.
+ *
+ * When entries change state (e.g., draft → published), their IDs change and all relations are recreated.
+ * While the order of relations from the entry's perspective is maintained (as they're created in order),
+ * the inverse relations (from related entries' perspective) would all appear last in order since they're new.
+ *
+ * Example:
+ * ```
+ * Before publish:
+ *   Article(id:1) →(order:1)→ Category(id:5)
+ *   Category(id:5) →(order:3)→ Article(id:1)
+ *
+ * After publish (without sync):
+ *   Article(id:2) →(order:1)→ Category(id:5)    [order preserved]
+ *   Category(id:5) →(order:99)→ Article(id:2)   [order lost - appears last]
+ *
+ * After sync:
+ *   Article(id:2) →(order:1)→ Category(id:5)    [order preserved]
+ *   Category(id:5) →(order:3)→ Article(id:2)    [order restored]
+ * ```
+ *
+ * @param oldEntries - Array of previous entry versions with their IDs and locales
+ * @param newEntries - Array of new entry versions with their IDs and locales
+ * @param existingRelations - Array of join table data containing the relations to be updated
+ */ const sync = async (oldEntries, newEntries, existingRelations)=>{
+    // Group new entries by locale for easier lookup
+    const newEntriesByLocale = keyBy('locale', newEntries);
+    // Create a mapping of old entry IDs to new entry IDs based on locale
+    const entryIdMapping = oldEntries.reduce((acc, oldEntry)=>{
+        const newEntry = newEntriesByLocale[oldEntry.locale];
+        if (!newEntry) return acc;
+        acc[oldEntry.id] = newEntry.id;
+        return acc;
+    }, {});
+    await strapi.db.transaction(async ({ trx })=>{
+        for (const { joinTable, relations } of existingRelations){
+            const sourceColumn = joinTable.inverseJoinColumn.name;
+            const targetColumn = joinTable.joinColumn.name;
+            const orderColumn = joinTable.orderColumnName;
+            // Failsafe in case those don't exist
+            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
+                });
+            });
+        }
+    });
+};
+
+export { load, sync };
+//# sourceMappingURL=bidirectional-relations.mjs.map

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

@@ -0,0 +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":"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"}

package/dist/services/document-service/utils/populate.d.ts

@@ -1,3 +1,10 @@
-import { Common } from '@strapi/types';
-export declare const getDeepPopulate: (uid: Common.UID.Schema) => any;
+import type { UID } from '@strapi/types';
+interface Options {
+    /**
+     * Fields to select when populating relations
+     */
+    relationalFields?: string[];
+}
+export declare const getDeepPopulate: (uid: UID.Schema, opts?: Options) => any;
+export {};
 //# sourceMappingURL=populate.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"populate.d.ts","sourceRoot":"","sources":["../../../../src/services/document-service/utils/populate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAIvC,eAAO,MAAM,eAAe,QAAS,OAAO,GAAG,CAAC,MAAM,QA8CrD,CAAC"}
+{"version":3,"file":"populate.d.ts","sourceRoot":"","sources":["../../../../src/services/document-service/utils/populate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,eAAe,CAAC;AAGzC,UAAU,OAAO;IACf;;OAEG;IACH,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC7B;AAKD,eAAO,MAAM,eAAe,QAAS,IAAI,MAAM,SAAQ,OAAO,QAwD7D,CAAC"}

package/dist/services/document-service/utils/populate.js

@@ -1,41 +1,71 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const strapiUtils = require("@strapi/utils");
-const getDeepPopulate = (uid) => {
-  const model = strapi.getModel(uid);
-  const attributes = Object.entries(model.attributes);
-  return attributes.reduce((acc, [attributeName, attribute]) => {
-    switch (attribute.type) {
-      case "relation": {
-        const isVisible = strapiUtils.contentTypes.isVisibleAttribute(model, attributeName);
-        if (isVisible) {
-          acc[attributeName] = { fields: ["document_id", "locale"] };
+'use strict';
+
+var strapiUtils = require('@strapi/utils');
+
+const { CREATED_BY_ATTRIBUTE, UPDATED_BY_ATTRIBUTE } = strapiUtils.contentTypes.constants;
+// We want to build a populate object based on the schema
+const getDeepPopulate = (uid, opts = {})=>{
+    const model = strapi.getModel(uid);
+    const attributes = Object.entries(model.attributes);
+    return attributes.reduce((acc, [attributeName, attribute])=>{
+        switch(attribute.type){
+            case 'relation':
+                {
+                    // TODO: Support polymorphic relations
+                    const isMorphRelation = attribute.relation.toLowerCase().startsWith('morph');
+                    if (isMorphRelation) {
+                        break;
+                    }
+                    // Ignore not visible fields other than createdBy and updatedBy
+                    const isVisible = strapiUtils.contentTypes.isVisibleAttribute(model, attributeName);
+                    const isCreatorField = [
+                        CREATED_BY_ATTRIBUTE,
+                        UPDATED_BY_ATTRIBUTE
+                    ].includes(attributeName);
+                    if (isVisible || isCreatorField) {
+                        acc[attributeName] = {
+                            select: opts.relationalFields
+                        };
+                    }
+                    break;
+                }
+            case 'media':
+                {
+                    // We populate all media fields for completeness of webhook responses
+                    // see https://github.com/strapi/strapi/issues/21546
+                    acc[attributeName] = {
+                        select: [
+                            '*'
+                        ]
+                    };
+                    break;
+                }
+            case 'component':
+                {
+                    const populate = getDeepPopulate(attribute.component, opts);
+                    acc[attributeName] = {
+                        populate
+                    };
+                    break;
+                }
+            case 'dynamiczone':
+                {
+                    // Use fragments to populate the dynamic zone components
+                    const populatedComponents = (attribute.components || []).reduce((acc, componentUID)=>{
+                        acc[componentUID] = {
+                            populate: getDeepPopulate(componentUID, opts)
+                        };
+                        return acc;
+                    }, {});
+                    acc[attributeName] = {
+                        on: populatedComponents
+                    };
+                    break;
+                }
         }
-        break;
-      }
-      case "media": {
-        acc[attributeName] = { fields: ["id"] };
-        break;
-      }
-      case "component": {
-        const populate = getDeepPopulate(attribute.component);
-        acc[attributeName] = { populate };
-        break;
-      }
-      case "dynamiczone": {
-        const populatedComponents = (attribute.components || []).reduce(
-          (acc2, componentUID) => {
-            acc2[componentUID] = { populate: getDeepPopulate(componentUID) };
-            return acc2;
-          },
-          {}
-        );
-        acc[attributeName] = { on: populatedComponents };
-        break;
-      }
-    }
-    return acc;
-  }, {});
+        return acc;
+    }, {});
 };
+
 exports.getDeepPopulate = getDeepPopulate;
 //# sourceMappingURL=populate.js.map

package/dist/services/document-service/utils/populate.js.map

@@ -1 +1 @@
-{"version":3,"file":"populate.js","sources":["../../../../src/services/document-service/utils/populate.ts"],"sourcesContent":["import { Common } from '@strapi/types';\nimport { contentTypes } from '@strapi/utils';\n\n// We want to build a populate object based on the schema\nexport const getDeepPopulate = (uid: Common.UID.Schema) => {\n  const model = strapi.getModel(uid);\n  const attributes = Object.entries(model.attributes);\n\n  return attributes.reduce((acc: any, [attributeName, attribute]) => {\n    switch (attribute.type) {\n      case 'relation': {\n        // TODO: Should this just be a plain list?\n        // Ignore createdBy, updatedBy, ...\n        const isVisible = contentTypes.isVisibleAttribute(model, attributeName);\n        if (isVisible) {\n          acc[attributeName] = { fields: ['document_id', 'locale'] };\n        }\n        break;\n      }\n\n      case 'media': {\n        acc[attributeName] = { fields: ['id'] };\n        break;\n      }\n\n      case 'component': {\n        const populate = getDeepPopulate(attribute.component);\n        acc[attributeName] = { populate };\n        break;\n      }\n\n      case 'dynamiczone': {\n        // Use fragments to populate the dynamic zone components\n        const populatedComponents = (attribute.components || []).reduce(\n          (acc: any, componentUID: Common.UID.Component) => {\n            acc[componentUID] = { populate: getDeepPopulate(componentUID) };\n            return acc;\n          },\n          {}\n        );\n\n        acc[attributeName] = { on: populatedComponents };\n        break;\n      }\n      default:\n        break;\n    }\n\n    return acc;\n  }, {});\n};\n"],"names":["contentTypes","acc"],"mappings":";;;AAIa,MAAA,kBAAkB,CAAC,QAA2B;AACnD,QAAA,QAAQ,OAAO,SAAS,GAAG;AACjC,QAAM,aAAa,OAAO,QAAQ,MAAM,UAAU;AAElD,SAAO,WAAW,OAAO,CAAC,KAAU,CAAC,eAAe,SAAS,MAAM;AACjE,YAAQ,UAAU,MAAM;AAAA,MACtB,KAAK,YAAY;AAGf,cAAM,YAAYA,YAAA,aAAa,mBAAmB,OAAO,aAAa;AACtE,YAAI,WAAW;AACb,cAAI,aAAa,IAAI,EAAE,QAAQ,CAAC,eAAe,QAAQ;QACzD;AACA;AAAA,MACF;AAAA,MAEA,KAAK,SAAS;AACZ,YAAI,aAAa,IAAI,EAAE,QAAQ,CAAC,IAAI,EAAE;AACtC;AAAA,MACF;AAAA,MAEA,KAAK,aAAa;AACV,cAAA,WAAW,gBAAgB,UAAU,SAAS;AAChD,YAAA,aAAa,IAAI,EAAE;AACvB;AAAA,MACF;AAAA,MAEA,KAAK,eAAe;AAElB,cAAM,uBAAuB,UAAU,cAAc,CAAI,GAAA;AAAA,UACvD,CAACC,MAAU,iBAAuC;AAChDA,iBAAI,YAAY,IAAI,EAAE,UAAU,gBAAgB,YAAY;AACrDA,mBAAAA;AAAAA,UACT;AAAA,UACA,CAAC;AAAA,QAAA;AAGH,YAAI,aAAa,IAAI,EAAE,IAAI,oBAAoB;AAC/C;AAAA,MACF;AAAA,IAGF;AAEO,WAAA;AAAA,EACT,GAAG,CAAE,CAAA;AACP;;"}
+{"version":3,"file":"populate.js","sources":["../../../../src/services/document-service/utils/populate.ts"],"sourcesContent":["import type { UID } from '@strapi/types';\nimport { contentTypes } from '@strapi/utils';\n\ninterface Options {\n  /**\n   * Fields to select when populating relations\n   */\n  relationalFields?: string[];\n}\n\nconst { CREATED_BY_ATTRIBUTE, UPDATED_BY_ATTRIBUTE } = contentTypes.constants;\n\n// We want to build a populate object based on the schema\nexport const getDeepPopulate = (uid: UID.Schema, opts: Options = {}) => {\n  const model = strapi.getModel(uid);\n  const attributes = Object.entries(model.attributes);\n\n  return attributes.reduce((acc: any, [attributeName, attribute]) => {\n    switch (attribute.type) {\n      case 'relation': {\n        // TODO: Support polymorphic relations\n        const isMorphRelation = attribute.relation.toLowerCase().startsWith('morph');\n        if (isMorphRelation) {\n          break;\n        }\n\n        // Ignore not visible fields other than createdBy and updatedBy\n        const isVisible = contentTypes.isVisibleAttribute(model, attributeName);\n        const isCreatorField = [CREATED_BY_ATTRIBUTE, UPDATED_BY_ATTRIBUTE].includes(attributeName);\n\n        if (isVisible || isCreatorField) {\n          acc[attributeName] = { select: opts.relationalFields };\n        }\n\n        break;\n      }\n\n      case 'media': {\n        // We populate all media fields for completeness of webhook responses\n        // see https://github.com/strapi/strapi/issues/21546\n        acc[attributeName] = { select: ['*'] };\n        break;\n      }\n\n      case 'component': {\n        const populate = getDeepPopulate(attribute.component, opts);\n        acc[attributeName] = { populate };\n        break;\n      }\n\n      case 'dynamiczone': {\n        // Use fragments to populate the dynamic zone components\n        const populatedComponents = (attribute.components || []).reduce(\n          (acc: any, componentUID: UID.Component) => {\n            acc[componentUID] = { populate: getDeepPopulate(componentUID, opts) };\n            return acc;\n          },\n          {}\n        );\n\n        acc[attributeName] = { on: populatedComponents };\n        break;\n      }\n      default:\n        break;\n    }\n\n    return acc;\n  }, {});\n};\n"],"names":["CREATED_BY_ATTRIBUTE","UPDATED_BY_ATTRIBUTE","contentTypes","constants","getDeepPopulate","uid","opts","model","strapi","getModel","attributes","Object","entries","reduce","acc","attributeName","attribute","type","isMorphRelation","relation","toLowerCase","startsWith","isVisible","isVisibleAttribute","isCreatorField","includes","select","relationalFields","populate","component","populatedComponents","components","componentUID","on"],"mappings":";;;;AAUA,MAAM,EAAEA,oBAAoB,EAAEC,oBAAoB,EAAE,GAAGC,yBAAaC,SAAS;AAE7E;MACaC,eAAkB,GAAA,CAACC,GAAiBC,EAAAA,IAAAA,GAAgB,EAAE,GAAA;IACjE,MAAMC,KAAAA,GAAQC,MAAOC,CAAAA,QAAQ,CAACJ,GAAAA,CAAAA;AAC9B,IAAA,MAAMK,UAAaC,GAAAA,MAAAA,CAAOC,OAAO,CAACL,MAAMG,UAAU,CAAA;AAElD,IAAA,OAAOA,WAAWG,MAAM,CAAC,CAACC,GAAU,EAAA,CAACC,eAAeC,SAAU,CAAA,GAAA;AAC5D,QAAA,OAAQA,UAAUC,IAAI;YACpB,KAAK,UAAA;AAAY,gBAAA;;AAEf,oBAAA,MAAMC,kBAAkBF,SAAUG,CAAAA,QAAQ,CAACC,WAAW,EAAA,CAAGC,UAAU,CAAC,OAAA,CAAA;AACpE,oBAAA,IAAIH,eAAiB,EAAA;AACnB,wBAAA;AACF;;AAGA,oBAAA,MAAMI,SAAYpB,GAAAA,wBAAAA,CAAaqB,kBAAkB,CAAChB,KAAOQ,EAAAA,aAAAA,CAAAA;AACzD,oBAAA,MAAMS,cAAiB,GAAA;AAACxB,wBAAAA,oBAAAA;AAAsBC,wBAAAA;AAAqB,qBAAA,CAACwB,QAAQ,CAACV,aAAAA,CAAAA;AAE7E,oBAAA,IAAIO,aAAaE,cAAgB,EAAA;wBAC/BV,GAAG,CAACC,cAAc,GAAG;AAAEW,4BAAAA,MAAAA,EAAQpB,KAAKqB;AAAiB,yBAAA;AACvD;AAEA,oBAAA;AACF;YAEA,KAAK,OAAA;AAAS,gBAAA;;;oBAGZb,GAAG,CAACC,cAAc,GAAG;wBAAEW,MAAQ,EAAA;AAAC,4BAAA;AAAI;AAAC,qBAAA;AACrC,oBAAA;AACF;YAEA,KAAK,WAAA;AAAa,gBAAA;AAChB,oBAAA,MAAME,QAAWxB,GAAAA,eAAAA,CAAgBY,SAAUa,CAAAA,SAAS,EAAEvB,IAAAA,CAAAA;oBACtDQ,GAAG,CAACC,cAAc,GAAG;AAAEa,wBAAAA;AAAS,qBAAA;AAChC,oBAAA;AACF;YAEA,KAAK,aAAA;AAAe,gBAAA;;AAElB,oBAAA,MAAME,mBAAsB,GAACd,CAAAA,SAAAA,CAAUe,UAAU,IAAI,EAAC,EAAGlB,MAAM,CAC7D,CAACC,GAAUkB,EAAAA,YAAAA,GAAAA;wBACTlB,GAAG,CAACkB,aAAa,GAAG;AAAEJ,4BAAAA,QAAAA,EAAUxB,gBAAgB4B,YAAc1B,EAAAA,IAAAA;AAAM,yBAAA;wBACpE,OAAOQ,GAAAA;AACT,qBAAA,EACA,EAAC,CAAA;oBAGHA,GAAG,CAACC,cAAc,GAAG;wBAAEkB,EAAIH,EAAAA;AAAoB,qBAAA;AAC/C,oBAAA;AACF;AAGF;QAEA,OAAOhB,GAAAA;AACT,KAAA,EAAG,EAAC,CAAA;AACN;;;;"}

package/dist/services/document-service/utils/populate.mjs

@@ -1,41 +1,69 @@
-import { contentTypes } from "@strapi/utils";
-const getDeepPopulate = (uid) => {
-  const model = strapi.getModel(uid);
-  const attributes = Object.entries(model.attributes);
-  return attributes.reduce((acc, [attributeName, attribute]) => {
-    switch (attribute.type) {
-      case "relation": {
-        const isVisible = contentTypes.isVisibleAttribute(model, attributeName);
-        if (isVisible) {
-          acc[attributeName] = { fields: ["document_id", "locale"] };
+import { contentTypes } from '@strapi/utils';
+
+const { CREATED_BY_ATTRIBUTE, UPDATED_BY_ATTRIBUTE } = contentTypes.constants;
+// We want to build a populate object based on the schema
+const getDeepPopulate = (uid, opts = {})=>{
+    const model = strapi.getModel(uid);
+    const attributes = Object.entries(model.attributes);
+    return attributes.reduce((acc, [attributeName, attribute])=>{
+        switch(attribute.type){
+            case 'relation':
+                {
+                    // TODO: Support polymorphic relations
+                    const isMorphRelation = attribute.relation.toLowerCase().startsWith('morph');
+                    if (isMorphRelation) {
+                        break;
+                    }
+                    // Ignore not visible fields other than createdBy and updatedBy
+                    const isVisible = contentTypes.isVisibleAttribute(model, attributeName);
+                    const isCreatorField = [
+                        CREATED_BY_ATTRIBUTE,
+                        UPDATED_BY_ATTRIBUTE
+                    ].includes(attributeName);
+                    if (isVisible || isCreatorField) {
+                        acc[attributeName] = {
+                            select: opts.relationalFields
+                        };
+                    }
+                    break;
+                }
+            case 'media':
+                {
+                    // We populate all media fields for completeness of webhook responses
+                    // see https://github.com/strapi/strapi/issues/21546
+                    acc[attributeName] = {
+                        select: [
+                            '*'
+                        ]
+                    };
+                    break;
+                }
+            case 'component':
+                {
+                    const populate = getDeepPopulate(attribute.component, opts);
+                    acc[attributeName] = {
+                        populate
+                    };
+                    break;
+                }
+            case 'dynamiczone':
+                {
+                    // Use fragments to populate the dynamic zone components
+                    const populatedComponents = (attribute.components || []).reduce((acc, componentUID)=>{
+                        acc[componentUID] = {
+                            populate: getDeepPopulate(componentUID, opts)
+                        };
+                        return acc;
+                    }, {});
+                    acc[attributeName] = {
+                        on: populatedComponents
+                    };
+                    break;
+                }
         }
-        break;
-      }
-      case "media": {
-        acc[attributeName] = { fields: ["id"] };
-        break;
-      }
-      case "component": {
-        const populate = getDeepPopulate(attribute.component);
-        acc[attributeName] = { populate };
-        break;
-      }
-      case "dynamiczone": {
-        const populatedComponents = (attribute.components || []).reduce(
-          (acc2, componentUID) => {
-            acc2[componentUID] = { populate: getDeepPopulate(componentUID) };
-            return acc2;
-          },
-          {}
-        );
-        acc[attributeName] = { on: populatedComponents };
-        break;
-      }
-    }
-    return acc;
-  }, {});
-};
-export {
-  getDeepPopulate
+        return acc;
+    }, {});
 };
+
+export { getDeepPopulate };
 //# sourceMappingURL=populate.mjs.map

package/dist/services/document-service/utils/populate.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"populate.mjs","sources":["../../../../src/services/document-service/utils/populate.ts"],"sourcesContent":["import { Common } from '@strapi/types';\nimport { contentTypes } from '@strapi/utils';\n\n// We want to build a populate object based on the schema\nexport const getDeepPopulate = (uid: Common.UID.Schema) => {\n  const model = strapi.getModel(uid);\n  const attributes = Object.entries(model.attributes);\n\n  return attributes.reduce((acc: any, [attributeName, attribute]) => {\n    switch (attribute.type) {\n      case 'relation': {\n        // TODO: Should this just be a plain list?\n        // Ignore createdBy, updatedBy, ...\n        const isVisible = contentTypes.isVisibleAttribute(model, attributeName);\n        if (isVisible) {\n          acc[attributeName] = { fields: ['document_id', 'locale'] };\n        }\n        break;\n      }\n\n      case 'media': {\n        acc[attributeName] = { fields: ['id'] };\n        break;\n      }\n\n      case 'component': {\n        const populate = getDeepPopulate(attribute.component);\n        acc[attributeName] = { populate };\n        break;\n      }\n\n      case 'dynamiczone': {\n        // Use fragments to populate the dynamic zone components\n        const populatedComponents = (attribute.components || []).reduce(\n          (acc: any, componentUID: Common.UID.Component) => {\n            acc[componentUID] = { populate: getDeepPopulate(componentUID) };\n            return acc;\n          },\n          {}\n        );\n\n        acc[attributeName] = { on: populatedComponents };\n        break;\n      }\n      default:\n        break;\n    }\n\n    return acc;\n  }, {});\n};\n"],"names":["acc"],"mappings":";AAIa,MAAA,kBAAkB,CAAC,QAA2B;AACnD,QAAA,QAAQ,OAAO,SAAS,GAAG;AACjC,QAAM,aAAa,OAAO,QAAQ,MAAM,UAAU;AAElD,SAAO,WAAW,OAAO,CAAC,KAAU,CAAC,eAAe,SAAS,MAAM;AACjE,YAAQ,UAAU,MAAM;AAAA,MACtB,KAAK,YAAY;AAGf,cAAM,YAAY,aAAa,mBAAmB,OAAO,aAAa;AACtE,YAAI,WAAW;AACb,cAAI,aAAa,IAAI,EAAE,QAAQ,CAAC,eAAe,QAAQ;QACzD;AACA;AAAA,MACF;AAAA,MAEA,KAAK,SAAS;AACZ,YAAI,aAAa,IAAI,EAAE,QAAQ,CAAC,IAAI,EAAE;AACtC;AAAA,MACF;AAAA,MAEA,KAAK,aAAa;AACV,cAAA,WAAW,gBAAgB,UAAU,SAAS;AAChD,YAAA,aAAa,IAAI,EAAE;AACvB;AAAA,MACF;AAAA,MAEA,KAAK,eAAe;AAElB,cAAM,uBAAuB,UAAU,cAAc,CAAI,GAAA;AAAA,UACvD,CAACA,MAAU,iBAAuC;AAChDA,iBAAI,YAAY,IAAI,EAAE,UAAU,gBAAgB,YAAY;AACrDA,mBAAAA;AAAAA,UACT;AAAA,UACA,CAAC;AAAA,QAAA;AAGH,YAAI,aAAa,IAAI,EAAE,IAAI,oBAAoB;AAC/C;AAAA,MACF;AAAA,IAGF;AAEO,WAAA;AAAA,EACT,GAAG,CAAE,CAAA;AACP;"}
+{"version":3,"file":"populate.mjs","sources":["../../../../src/services/document-service/utils/populate.ts"],"sourcesContent":["import type { UID } from '@strapi/types';\nimport { contentTypes } from '@strapi/utils';\n\ninterface Options {\n  /**\n   * Fields to select when populating relations\n   */\n  relationalFields?: string[];\n}\n\nconst { CREATED_BY_ATTRIBUTE, UPDATED_BY_ATTRIBUTE } = contentTypes.constants;\n\n// We want to build a populate object based on the schema\nexport const getDeepPopulate = (uid: UID.Schema, opts: Options = {}) => {\n  const model = strapi.getModel(uid);\n  const attributes = Object.entries(model.attributes);\n\n  return attributes.reduce((acc: any, [attributeName, attribute]) => {\n    switch (attribute.type) {\n      case 'relation': {\n        // TODO: Support polymorphic relations\n        const isMorphRelation = attribute.relation.toLowerCase().startsWith('morph');\n        if (isMorphRelation) {\n          break;\n        }\n\n        // Ignore not visible fields other than createdBy and updatedBy\n        const isVisible = contentTypes.isVisibleAttribute(model, attributeName);\n        const isCreatorField = [CREATED_BY_ATTRIBUTE, UPDATED_BY_ATTRIBUTE].includes(attributeName);\n\n        if (isVisible || isCreatorField) {\n          acc[attributeName] = { select: opts.relationalFields };\n        }\n\n        break;\n      }\n\n      case 'media': {\n        // We populate all media fields for completeness of webhook responses\n        // see https://github.com/strapi/strapi/issues/21546\n        acc[attributeName] = { select: ['*'] };\n        break;\n      }\n\n      case 'component': {\n        const populate = getDeepPopulate(attribute.component, opts);\n        acc[attributeName] = { populate };\n        break;\n      }\n\n      case 'dynamiczone': {\n        // Use fragments to populate the dynamic zone components\n        const populatedComponents = (attribute.components || []).reduce(\n          (acc: any, componentUID: UID.Component) => {\n            acc[componentUID] = { populate: getDeepPopulate(componentUID, opts) };\n            return acc;\n          },\n          {}\n        );\n\n        acc[attributeName] = { on: populatedComponents };\n        break;\n      }\n      default:\n        break;\n    }\n\n    return acc;\n  }, {});\n};\n"],"names":["CREATED_BY_ATTRIBUTE","UPDATED_BY_ATTRIBUTE","contentTypes","constants","getDeepPopulate","uid","opts","model","strapi","getModel","attributes","Object","entries","reduce","acc","attributeName","attribute","type","isMorphRelation","relation","toLowerCase","startsWith","isVisible","isVisibleAttribute","isCreatorField","includes","select","relationalFields","populate","component","populatedComponents","components","componentUID","on"],"mappings":";;AAUA,MAAM,EAAEA,oBAAoB,EAAEC,oBAAoB,EAAE,GAAGC,aAAaC,SAAS;AAE7E;MACaC,eAAkB,GAAA,CAACC,GAAiBC,EAAAA,IAAAA,GAAgB,EAAE,GAAA;IACjE,MAAMC,KAAAA,GAAQC,MAAOC,CAAAA,QAAQ,CAACJ,GAAAA,CAAAA;AAC9B,IAAA,MAAMK,UAAaC,GAAAA,MAAAA,CAAOC,OAAO,CAACL,MAAMG,UAAU,CAAA;AAElD,IAAA,OAAOA,WAAWG,MAAM,CAAC,CAACC,GAAU,EAAA,CAACC,eAAeC,SAAU,CAAA,GAAA;AAC5D,QAAA,OAAQA,UAAUC,IAAI;YACpB,KAAK,UAAA;AAAY,gBAAA;;AAEf,oBAAA,MAAMC,kBAAkBF,SAAUG,CAAAA,QAAQ,CAACC,WAAW,EAAA,CAAGC,UAAU,CAAC,OAAA,CAAA;AACpE,oBAAA,IAAIH,eAAiB,EAAA;AACnB,wBAAA;AACF;;AAGA,oBAAA,MAAMI,SAAYpB,GAAAA,YAAAA,CAAaqB,kBAAkB,CAAChB,KAAOQ,EAAAA,aAAAA,CAAAA;AACzD,oBAAA,MAAMS,cAAiB,GAAA;AAACxB,wBAAAA,oBAAAA;AAAsBC,wBAAAA;AAAqB,qBAAA,CAACwB,QAAQ,CAACV,aAAAA,CAAAA;AAE7E,oBAAA,IAAIO,aAAaE,cAAgB,EAAA;wBAC/BV,GAAG,CAACC,cAAc,GAAG;AAAEW,4BAAAA,MAAAA,EAAQpB,KAAKqB;AAAiB,yBAAA;AACvD;AAEA,oBAAA;AACF;YAEA,KAAK,OAAA;AAAS,gBAAA;;;oBAGZb,GAAG,CAACC,cAAc,GAAG;wBAAEW,MAAQ,EAAA;AAAC,4BAAA;AAAI;AAAC,qBAAA;AACrC,oBAAA;AACF;YAEA,KAAK,WAAA;AAAa,gBAAA;AAChB,oBAAA,MAAME,QAAWxB,GAAAA,eAAAA,CAAgBY,SAAUa,CAAAA,SAAS,EAAEvB,IAAAA,CAAAA;oBACtDQ,GAAG,CAACC,cAAc,GAAG;AAAEa,wBAAAA;AAAS,qBAAA;AAChC,oBAAA;AACF;YAEA,KAAK,aAAA;AAAe,gBAAA;;AAElB,oBAAA,MAAME,mBAAsB,GAACd,CAAAA,SAAAA,CAAUe,UAAU,IAAI,EAAC,EAAGlB,MAAM,CAC7D,CAACC,GAAUkB,EAAAA,YAAAA,GAAAA;wBACTlB,GAAG,CAACkB,aAAa,GAAG;AAAEJ,4BAAAA,QAAAA,EAAUxB,gBAAgB4B,YAAc1B,EAAAA,IAAAA;AAAM,yBAAA;wBACpE,OAAOQ,GAAAA;AACT,qBAAA,EACA,EAAC,CAAA;oBAGHA,GAAG,CAACC,cAAc,GAAG;wBAAEkB,EAAIH,EAAAA;AAAoB,qBAAA;AAC/C,oBAAA;AACF;AAGF;QAEA,OAAOhB,GAAAA;AACT,KAAA,EAAG,EAAC,CAAA;AACN;;;;"}