@strapi/core 0.0.0-next.e98ae27d8c69c68823eb7c46cf329385637ba393 → 0.0.0-next.eb48c73c86cbc452c1ba8d727106f9ed9da0c834

package/dist/ee/index.d.ts

@@ -6,6 +6,7 @@ declare const _default: Readonly<{
     }) => Promise<void>;
     readonly isEE: boolean;
     readonly seats: number | undefined;
+    readonly type: string | undefined;
     features: Readonly<{
         list: () => {
             [key: string]: any;

package/dist/ee/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/ee/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;;;;;;;;;;;;;;;;;iCAsPb,MAAM;;;AAfnC,wBAiBG"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/ee/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;;;;;;;;;;;;;;;;;;iCA0Pb,MAAM;;;AAnBnC,wBAqBG"}

package/dist/ee/license.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"license.d.ts","sourceRoot":"","sources":["../../src/ee/license.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAI1C,UAAU,WAAW;IACnB,IAAI,EAAE,QAAQ,GAAG,QAAQ,GAAG,MAAM,CAAC;IACnC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,CAAC,CAAC;CACvE;AAkBD,cAAM,iBAAkB,SAAQ,KAAK;IACnC,cAAc,UAAS;gBAEX,OAAO,EAAE,MAAM,EAAE,cAAc,UAAQ;CAKpD;AAED,QAAA,MAAM,WAAW,cAAe,MAAM,uBASrC,CAAC;AAEF,QAAA,MAAM,aAAa,YAAa,MAAM,gBA2BrC,CAAC;AAMF,QAAA,MAAM,YAAY,eACJ;IAAE,MAAM,EAAE,KAAK,MAAM,CAAA;CAAE,OAC9B,MAAM,aACA,MAAM,iBA4BlB,CAAC;AAEF,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,YAAY,EAAE,iBAAiB,EAAE,CAAC"}
+{"version":3,"file":"license.d.ts","sourceRoot":"","sources":["../../src/ee/license.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAI1C,UAAU,WAAW;IACnB,IAAI,EAAE,QAAQ,GAAG,QAAQ,GAAG,MAAM,CAAC;IACnC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,CAAC,CAAC;CACvE;AAmBD,cAAM,iBAAkB,SAAQ,KAAK;IACnC,cAAc,UAAS;gBAEX,OAAO,EAAE,MAAM,EAAE,cAAc,UAAQ;CAKpD;AAED,QAAA,MAAM,WAAW,cAAe,MAAM,uBASrC,CAAC;AAEF,QAAA,MAAM,aAAa,YAAa,MAAM,gBA2BrC,CAAC;AAMF,QAAA,MAAM,YAAY,eACJ;IAAE,MAAM,EAAE,KAAK,MAAM,CAAA;CAAE,OAC9B,MAAM,aACA,MAAM,iBA4BlB,CAAC;AAEF,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,YAAY,EAAE,iBAAiB,EAAE,CAAC"}

package/dist/index.js

@@ -312,7 +312,7 @@ const getDirs = ({ appDir, distDir }, config)=>({
     });
 
 var name = "@strapi/core";
-var version = "0.0.0-next.e98ae27d8c69c68823eb7c46cf329385637ba393";
+var version = "0.0.0-next.eb48c73c86cbc452c1ba8d727106f9ed9da0c834";
 var description = "Core of Strapi";
 var homepage = "https://strapi.io";
 var bugs = {
@@ -368,14 +368,14 @@ var dependencies = {
     "@koa/cors": "5.0.0",
     "@koa/router": "12.0.2",
     "@paralleldrive/cuid2": "2.2.2",
-    "@strapi/admin": "0.0.0-next.e98ae27d8c69c68823eb7c46cf329385637ba393",
-    "@strapi/database": "0.0.0-next.e98ae27d8c69c68823eb7c46cf329385637ba393",
-    "@strapi/generators": "0.0.0-next.e98ae27d8c69c68823eb7c46cf329385637ba393",
-    "@strapi/logger": "0.0.0-next.e98ae27d8c69c68823eb7c46cf329385637ba393",
-    "@strapi/permissions": "0.0.0-next.e98ae27d8c69c68823eb7c46cf329385637ba393",
-    "@strapi/types": "0.0.0-next.e98ae27d8c69c68823eb7c46cf329385637ba393",
-    "@strapi/typescript-utils": "0.0.0-next.e98ae27d8c69c68823eb7c46cf329385637ba393",
-    "@strapi/utils": "0.0.0-next.e98ae27d8c69c68823eb7c46cf329385637ba393",
+    "@strapi/admin": "0.0.0-next.eb48c73c86cbc452c1ba8d727106f9ed9da0c834",
+    "@strapi/database": "0.0.0-next.eb48c73c86cbc452c1ba8d727106f9ed9da0c834",
+    "@strapi/generators": "0.0.0-next.eb48c73c86cbc452c1ba8d727106f9ed9da0c834",
+    "@strapi/logger": "0.0.0-next.eb48c73c86cbc452c1ba8d727106f9ed9da0c834",
+    "@strapi/permissions": "0.0.0-next.eb48c73c86cbc452c1ba8d727106f9ed9da0c834",
+    "@strapi/types": "0.0.0-next.eb48c73c86cbc452c1ba8d727106f9ed9da0c834",
+    "@strapi/typescript-utils": "0.0.0-next.eb48c73c86cbc452c1ba8d727106f9ed9da0c834",
+    "@strapi/utils": "0.0.0-next.eb48c73c86cbc452c1ba8d727106f9ed9da0c834",
     bcryptjs: "2.4.3",
     boxen: "5.1.2",
     chalk: "4.1.2",
@@ -438,9 +438,9 @@ var devDependencies = {
     "@types/node": "18.19.24",
     "@types/node-schedule": "2.1.7",
     "@types/statuses": "2.0.1",
-    "eslint-config-custom": "0.0.0-next.e98ae27d8c69c68823eb7c46cf329385637ba393",
+    "eslint-config-custom": "0.0.0-next.eb48c73c86cbc452c1ba8d727106f9ed9da0c834",
     supertest: "6.3.3",
-    tsconfig: "0.0.0-next.e98ae27d8c69c68823eb7c46cf329385637ba393"
+    tsconfig: "0.0.0-next.eb48c73c86cbc452c1ba8d727106f9ed9da0c834"
 };
 var engines = {
     node: ">=18.0.0 <=22.x.x",
@@ -1201,6 +1201,9 @@ const DEFAULT_FEATURES = {
             options: {
                 retentionDays: 99999
             }
+        },
+        {
+            name: 'cms-advanced-preview'
         }
     ]
 };
@@ -1515,6 +1518,9 @@ var index = Object.freeze({
     get seats () {
         return ee.licenseInfo.seats;
     },
+    get type () {
+        return ee.licenseInfo.type;
+    },
     features: Object.freeze({
         list,
         get,
@@ -6770,7 +6776,7 @@ const EVENTS = {
  * Loads lingering relations that need to be updated when overriding a published or draft entry.
  * This is necessary because the relations are uni-directional and the target entry is not aware of the source entry.
  * This is not the case for bi-directional relations, where the target entry is also linked to the source entry.
- */ const load = async (uid, { oldVersions, newVersions })=>{
+ */ const load$1 = async (uid, { oldVersions, newVersions })=>{
     const updates = [];
     // Iterate all components and content types to find relations that need to be updated
     await strapi.db.transaction(async ({ trx })=>{
@@ -6845,7 +6851,7 @@ const EVENTS = {
  * @param oldEntries The old entries that are being overridden
  * @param newEntries The new entries that are overriding the old ones
  * @param oldRelations The relations that were previously loaded with `load` @see load
- */ const sync = async (oldEntries, newEntries, oldRelations)=>{
+ */ const sync$1 = async (oldEntries, newEntries, oldRelations)=>{
     /**
    * Create a map of old entry ids to new entry ids
    *
@@ -6875,6 +6881,146 @@ const EVENTS = {
     });
 };
 
+/**
+ * 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
+                });
+            });
+        }
+    });
+};
+
 const textNodeValidator = strapiUtils.yup.object().shape({
     type: strapiUtils.yup.string().equals([
         'text'
@@ -7903,7 +8049,11 @@ const createContentTypeRepository = (uid, validator = entityValidator)=>{
             })
         ]);
         // Load any unidirectional relation targetting the old published entries
-        const relationsToSync = await load(uid, {
+        const relationsToSync = await load$1(uid, {
+            newVersions: draftsToPublish,
+            oldVersions: oldPublishedVersions
+        });
+        const bidirectionalRelationsToSync = await load(uid, {
             newVersions: draftsToPublish,
             oldVersions: oldPublishedVersions
         });
@@ -7912,10 +8062,14 @@ const createContentTypeRepository = (uid, validator = entityValidator)=>{
         // Transform draft entry data and create published versions
         const publishedEntries = await strapiUtils.async.map(draftsToPublish, (draft)=>entries.publish(draft, queryParams));
         // Sync unidirectional relations with the new published entries
-        await sync([
+        await sync$1([
             ...oldPublishedVersions,
             ...draftsToPublish
         ], publishedEntries, relationsToSync);
+        await sync([
+            ...oldPublishedVersions,
+            ...draftsToPublish
+        ], publishedEntries, bidirectionalRelationsToSync);
         publishedEntries.forEach(emitEvent('entry.publish'));
         return {
             documentId,
@@ -7973,7 +8127,11 @@ const createContentTypeRepository = (uid, validator = entityValidator)=>{
             })
         ]);
         // Load any unidirectional relation targeting the old drafts
-        const relationsToSync = await load(uid, {
+        const relationsToSync = await load$1(uid, {
+            newVersions: versionsToDraft,
+            oldVersions: oldDrafts
+        });
+        const bidirectionalRelationsToSync = await load(uid, {
             newVersions: versionsToDraft,
             oldVersions: oldDrafts
         });
@@ -7982,10 +8140,14 @@ const createContentTypeRepository = (uid, validator = entityValidator)=>{
         // Transform published entry data and create draft versions
         const draftEntries = await strapiUtils.async.map(versionsToDraft, (entry)=>entries.discardDraft(entry, queryParams));
         // Sync unidirectional relations with the new draft entries
-        await sync([
+        await sync$1([
             ...oldDrafts,
             ...versionsToDraft
         ], draftEntries, relationsToSync);
+        await sync([
+            ...oldDrafts,
+            ...versionsToDraft
+        ], draftEntries, bidirectionalRelationsToSync);
         draftEntries.forEach(emitEvent('entry.draft-discard'));
         return {
             documentId,