@strapi/core 0.0.0-experimental.fc1ac2acd58c8a5a858679956b6d102ac5ee4011 → 0.0.0-experimental.fca58d9b01ba89012d84a58a20556a6fd716cb92

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

@@ -0,0 +1,130 @@
+'use strict';
+
+var fp = require('lodash/fp');
+var strapiUtils = require('@strapi/utils');
+
+const isNumeric = (value)=>{
+    if (Array.isArray(value)) return false; // Handle [1, 'docId'] case
+    const parsed = parseInt(value, 10);
+    return !Number.isNaN(parsed);
+};
+const toArray = (value)=>{
+    // Keep value as it is if it's a nullish value
+    if (fp.isNil(value)) return value;
+    if (Array.isArray(value)) return value;
+    return [
+        value
+    ];
+};
+/**
+ * There are multiple ways to create Strapi relations.
+ * This is a utility to traverse and transform relation data
+ *
+ *
+ * For consistency and ease of use, the response will always be an object with the following shape:
+ * { set: [{...}], connect: [{...}], disconnect: [{...}] }
+ *
+ * @example
+ * transformRelationData({
+ *  onLongHand: (relation) => {
+ *    // Change the id of the relation
+ *    return { id: 'other' };
+ *  },
+ * }, relation)
+ */ const mapRelation = async (callback, rel, isRecursive = false)=>{
+    let relation = rel;
+    const wrapInSet = (value)=>{
+        // Ignore wrapping if it's a recursive call
+        if (isRecursive) {
+            return value;
+        }
+        return {
+            set: toArray(value)
+        };
+    };
+    // undefined | null
+    if (fp.isNil(relation)) {
+        return callback(relation);
+    }
+    // LongHand[] | ShortHand[]
+    if (Array.isArray(relation)) {
+        return strapiUtils.async.map(relation, (r)=>mapRelation(callback, r, true)).then((result)=>result.flat().filter(Boolean)).then(wrapInSet);
+    }
+    // LongHand
+    if (fp.isObject(relation)) {
+        // { id: 1 } || { documentId: 1 }
+        if ('id' in relation || 'documentId' in relation) {
+            const result = await callback(relation);
+            return wrapInSet(result);
+        }
+        // If not connecting anything, return default visitor
+        if (!relation.set && !relation.disconnect && !relation.connect) {
+            return callback(relation);
+        }
+        // { set }
+        if (relation.set) {
+            const set = await mapRelation(callback, relation.set, true);
+            relation = {
+                ...relation,
+                set: toArray(set)
+            };
+        }
+        // { disconnect}
+        if (relation.disconnect) {
+            const disconnect = await mapRelation(callback, relation.disconnect, true);
+            relation = {
+                ...relation,
+                disconnect: toArray(disconnect)
+            };
+        }
+        // { connect }
+        if (relation.connect) {
+            // Transform the relation to connect
+            const connect = await mapRelation(callback, relation.connect, true);
+            relation = {
+                ...relation,
+                connect: toArray(connect)
+            };
+        }
+        return relation;
+    }
+    // ShortHand
+    if (isNumeric(relation)) {
+        const result = await callback({
+            id: relation
+        });
+        return wrapInSet(result);
+    }
+    if (typeof relation === 'string') {
+        const result = await callback({
+            documentId: relation
+        });
+        return wrapInSet(result);
+    }
+    // Anything else
+    return callback(relation);
+};
+/**
+ * Utility function, same as `traverseEntity` but only for relations.
+ */ const traverseEntityRelations = async (visitor, options, data)=>{
+    return strapiUtils.traverseEntity(async (options, utils)=>{
+        const { attribute } = options;
+        if (!attribute) {
+            return;
+        }
+        if (attribute.type !== 'relation') {
+            return;
+        }
+        // TODO: Handle join columns
+        if (attribute.useJoinTable === false) {
+            return;
+        }
+        return visitor(options, utils);
+    }, options, data);
+};
+const mapRelationCurried = fp.curry(mapRelation);
+const traverseEntityRelationsCurried = fp.curry(traverseEntityRelations);
+
+exports.mapRelation = mapRelationCurried;
+exports.traverseEntityRelations = traverseEntityRelationsCurried;
+//# sourceMappingURL=map-relation.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"map-relation.js","sources":["../../../../../../src/services/document-service/transform/relations/utils/map-relation.ts"],"sourcesContent":["/* eslint-disable node/no-callback-literal */\nimport { isObject, curry, isNil } from 'lodash/fp';\n\nimport { traverseEntity, async } from '@strapi/utils';\n\nimport { Relation } from './types';\n\nconst isNumeric = (value: any): value is number => {\n  if (Array.isArray(value)) return false; // Handle [1, 'docId'] case\n  const parsed = parseInt(value, 10);\n  return !Number.isNaN(parsed);\n};\n\nconst toArray = (value: any) => {\n  // Keep value as it is if it's a nullish value\n  if (isNil(value)) return value;\n  if (Array.isArray(value)) return value;\n\n  return [value];\n};\n\n/**\n * There are multiple ways to create Strapi relations.\n * This is a utility to traverse and transform relation data\n *\n *\n * For consistency and ease of use, the response will always be an object with the following shape:\n * { set: [{...}], connect: [{...}], disconnect: [{...}] }\n *\n * @example\n * transformRelationData({\n *  onLongHand: (relation) => {\n *    // Change the id of the relation\n *    return { id: 'other' };\n *  },\n * }, relation)\n */\nconst mapRelation = async (\n  callback: (relation: any) => any,\n  rel: Relation,\n  isRecursive = false\n): Promise<Relation> => {\n  let relation: Relation = rel;\n\n  const wrapInSet = (value: any) => {\n    // Ignore wrapping if it's a recursive call\n    if (isRecursive) {\n      return value;\n    }\n    return { set: toArray(value) };\n  };\n\n  // undefined | null\n  if (isNil(relation)) {\n    return callback(relation);\n  }\n\n  // LongHand[] | ShortHand[]\n  if (Array.isArray(relation)) {\n    return async\n      .map(relation, (r: Relation) => mapRelation(callback, r, true))\n      .then((result: any) => result.flat().filter(Boolean))\n      .then(wrapInSet);\n  }\n\n  // LongHand\n  if (isObject(relation)) {\n    // { id: 1 } || { documentId: 1 }\n    if ('id' in relation || 'documentId' in relation) {\n      const result = await callback(relation);\n      return wrapInSet(result);\n    }\n\n    // If not connecting anything, return default visitor\n    if (!relation.set && !relation.disconnect && !relation.connect) {\n      return callback(relation);\n    }\n\n    // { set }\n    if (relation.set) {\n      const set: any = await mapRelation(callback, relation.set, true);\n      relation = { ...relation, set: toArray(set) };\n    }\n\n    // { disconnect}\n    if (relation.disconnect) {\n      const disconnect: any = await mapRelation(callback, relation.disconnect, true);\n      relation = { ...relation, disconnect: toArray(disconnect) };\n    }\n\n    // { connect }\n    if (relation.connect) {\n      // Transform the relation to connect\n      const connect: any = await mapRelation(callback, relation.connect, true);\n      relation = { ...relation, connect: toArray(connect) };\n    }\n\n    return relation;\n  }\n\n  // ShortHand\n  if (isNumeric(relation)) {\n    const result = await callback({ id: relation });\n    return wrapInSet(result);\n  }\n\n  if (typeof relation === 'string') {\n    const result = await callback({ documentId: relation });\n    return wrapInSet(result);\n  }\n\n  // Anything else\n  return callback(relation);\n};\n\ntype TraverseEntity = Parameters<typeof traverseEntity>;\n\n/**\n * Utility function, same as `traverseEntity` but only for relations.\n */\nconst traverseEntityRelations = async (\n  visitor: TraverseEntity[0],\n  options: TraverseEntity[1],\n  data: TraverseEntity[2]\n) => {\n  return traverseEntity(\n    async (options, utils) => {\n      const { attribute } = options;\n\n      if (!attribute) {\n        return;\n      }\n\n      if (attribute.type !== 'relation') {\n        return;\n      }\n\n      // TODO: Handle join columns\n      if (attribute.useJoinTable === false) {\n        return;\n      }\n\n      return visitor(options, utils);\n    },\n    options,\n    data\n  );\n};\n\nconst mapRelationCurried = curry(mapRelation);\nconst traverseEntityRelationsCurried = curry(traverseEntityRelations);\n\nexport {\n  mapRelationCurried as mapRelation,\n  traverseEntityRelationsCurried as traverseEntityRelations,\n};\n"],"names":["isNumeric","value","Array","isArray","parsed","parseInt","Number","isNaN","toArray","isNil","mapRelation","callback","rel","isRecursive","relation","wrapInSet","set","async","map","r","then","result","flat","filter","Boolean","isObject","disconnect","connect","id","documentId","traverseEntityRelations","visitor","options","data","traverseEntity","utils","attribute","type","useJoinTable","mapRelationCurried","curry","traverseEntityRelationsCurried"],"mappings":"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"}

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

@@ -0,0 +1,127 @@
+import { curry, isNil, isObject } from 'lodash/fp';
+import { async, traverseEntity } from '@strapi/utils';
+
+const isNumeric = (value)=>{
+    if (Array.isArray(value)) return false; // Handle [1, 'docId'] case
+    const parsed = parseInt(value, 10);
+    return !Number.isNaN(parsed);
+};
+const toArray = (value)=>{
+    // Keep value as it is if it's a nullish value
+    if (isNil(value)) return value;
+    if (Array.isArray(value)) return value;
+    return [
+        value
+    ];
+};
+/**
+ * There are multiple ways to create Strapi relations.
+ * This is a utility to traverse and transform relation data
+ *
+ *
+ * For consistency and ease of use, the response will always be an object with the following shape:
+ * { set: [{...}], connect: [{...}], disconnect: [{...}] }
+ *
+ * @example
+ * transformRelationData({
+ *  onLongHand: (relation) => {
+ *    // Change the id of the relation
+ *    return { id: 'other' };
+ *  },
+ * }, relation)
+ */ const mapRelation = async (callback, rel, isRecursive = false)=>{
+    let relation = rel;
+    const wrapInSet = (value)=>{
+        // Ignore wrapping if it's a recursive call
+        if (isRecursive) {
+            return value;
+        }
+        return {
+            set: toArray(value)
+        };
+    };
+    // undefined | null
+    if (isNil(relation)) {
+        return callback(relation);
+    }
+    // LongHand[] | ShortHand[]
+    if (Array.isArray(relation)) {
+        return async.map(relation, (r)=>mapRelation(callback, r, true)).then((result)=>result.flat().filter(Boolean)).then(wrapInSet);
+    }
+    // LongHand
+    if (isObject(relation)) {
+        // { id: 1 } || { documentId: 1 }
+        if ('id' in relation || 'documentId' in relation) {
+            const result = await callback(relation);
+            return wrapInSet(result);
+        }
+        // If not connecting anything, return default visitor
+        if (!relation.set && !relation.disconnect && !relation.connect) {
+            return callback(relation);
+        }
+        // { set }
+        if (relation.set) {
+            const set = await mapRelation(callback, relation.set, true);
+            relation = {
+                ...relation,
+                set: toArray(set)
+            };
+        }
+        // { disconnect}
+        if (relation.disconnect) {
+            const disconnect = await mapRelation(callback, relation.disconnect, true);
+            relation = {
+                ...relation,
+                disconnect: toArray(disconnect)
+            };
+        }
+        // { connect }
+        if (relation.connect) {
+            // Transform the relation to connect
+            const connect = await mapRelation(callback, relation.connect, true);
+            relation = {
+                ...relation,
+                connect: toArray(connect)
+            };
+        }
+        return relation;
+    }
+    // ShortHand
+    if (isNumeric(relation)) {
+        const result = await callback({
+            id: relation
+        });
+        return wrapInSet(result);
+    }
+    if (typeof relation === 'string') {
+        const result = await callback({
+            documentId: relation
+        });
+        return wrapInSet(result);
+    }
+    // Anything else
+    return callback(relation);
+};
+/**
+ * Utility function, same as `traverseEntity` but only for relations.
+ */ const traverseEntityRelations = async (visitor, options, data)=>{
+    return traverseEntity(async (options, utils)=>{
+        const { attribute } = options;
+        if (!attribute) {
+            return;
+        }
+        if (attribute.type !== 'relation') {
+            return;
+        }
+        // TODO: Handle join columns
+        if (attribute.useJoinTable === false) {
+            return;
+        }
+        return visitor(options, utils);
+    }, options, data);
+};
+const mapRelationCurried = curry(mapRelation);
+const traverseEntityRelationsCurried = curry(traverseEntityRelations);
+
+export { mapRelationCurried as mapRelation, traverseEntityRelationsCurried as traverseEntityRelations };
+//# sourceMappingURL=map-relation.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"map-relation.mjs","sources":["../../../../../../src/services/document-service/transform/relations/utils/map-relation.ts"],"sourcesContent":["/* eslint-disable node/no-callback-literal */\nimport { isObject, curry, isNil } from 'lodash/fp';\n\nimport { traverseEntity, async } from '@strapi/utils';\n\nimport { Relation } from './types';\n\nconst isNumeric = (value: any): value is number => {\n  if (Array.isArray(value)) return false; // Handle [1, 'docId'] case\n  const parsed = parseInt(value, 10);\n  return !Number.isNaN(parsed);\n};\n\nconst toArray = (value: any) => {\n  // Keep value as it is if it's a nullish value\n  if (isNil(value)) return value;\n  if (Array.isArray(value)) return value;\n\n  return [value];\n};\n\n/**\n * There are multiple ways to create Strapi relations.\n * This is a utility to traverse and transform relation data\n *\n *\n * For consistency and ease of use, the response will always be an object with the following shape:\n * { set: [{...}], connect: [{...}], disconnect: [{...}] }\n *\n * @example\n * transformRelationData({\n *  onLongHand: (relation) => {\n *    // Change the id of the relation\n *    return { id: 'other' };\n *  },\n * }, relation)\n */\nconst mapRelation = async (\n  callback: (relation: any) => any,\n  rel: Relation,\n  isRecursive = false\n): Promise<Relation> => {\n  let relation: Relation = rel;\n\n  const wrapInSet = (value: any) => {\n    // Ignore wrapping if it's a recursive call\n    if (isRecursive) {\n      return value;\n    }\n    return { set: toArray(value) };\n  };\n\n  // undefined | null\n  if (isNil(relation)) {\n    return callback(relation);\n  }\n\n  // LongHand[] | ShortHand[]\n  if (Array.isArray(relation)) {\n    return async\n      .map(relation, (r: Relation) => mapRelation(callback, r, true))\n      .then((result: any) => result.flat().filter(Boolean))\n      .then(wrapInSet);\n  }\n\n  // LongHand\n  if (isObject(relation)) {\n    // { id: 1 } || { documentId: 1 }\n    if ('id' in relation || 'documentId' in relation) {\n      const result = await callback(relation);\n      return wrapInSet(result);\n    }\n\n    // If not connecting anything, return default visitor\n    if (!relation.set && !relation.disconnect && !relation.connect) {\n      return callback(relation);\n    }\n\n    // { set }\n    if (relation.set) {\n      const set: any = await mapRelation(callback, relation.set, true);\n      relation = { ...relation, set: toArray(set) };\n    }\n\n    // { disconnect}\n    if (relation.disconnect) {\n      const disconnect: any = await mapRelation(callback, relation.disconnect, true);\n      relation = { ...relation, disconnect: toArray(disconnect) };\n    }\n\n    // { connect }\n    if (relation.connect) {\n      // Transform the relation to connect\n      const connect: any = await mapRelation(callback, relation.connect, true);\n      relation = { ...relation, connect: toArray(connect) };\n    }\n\n    return relation;\n  }\n\n  // ShortHand\n  if (isNumeric(relation)) {\n    const result = await callback({ id: relation });\n    return wrapInSet(result);\n  }\n\n  if (typeof relation === 'string') {\n    const result = await callback({ documentId: relation });\n    return wrapInSet(result);\n  }\n\n  // Anything else\n  return callback(relation);\n};\n\ntype TraverseEntity = Parameters<typeof traverseEntity>;\n\n/**\n * Utility function, same as `traverseEntity` but only for relations.\n */\nconst traverseEntityRelations = async (\n  visitor: TraverseEntity[0],\n  options: TraverseEntity[1],\n  data: TraverseEntity[2]\n) => {\n  return traverseEntity(\n    async (options, utils) => {\n      const { attribute } = options;\n\n      if (!attribute) {\n        return;\n      }\n\n      if (attribute.type !== 'relation') {\n        return;\n      }\n\n      // TODO: Handle join columns\n      if (attribute.useJoinTable === false) {\n        return;\n      }\n\n      return visitor(options, utils);\n    },\n    options,\n    data\n  );\n};\n\nconst mapRelationCurried = curry(mapRelation);\nconst traverseEntityRelationsCurried = curry(traverseEntityRelations);\n\nexport {\n  mapRelationCurried as mapRelation,\n  traverseEntityRelationsCurried as traverseEntityRelations,\n};\n"],"names":["isNumeric","value","Array","isArray","parsed","parseInt","Number","isNaN","toArray","isNil","mapRelation","callback","rel","isRecursive","relation","wrapInSet","set","async","map","r","then","result","flat","filter","Boolean","isObject","disconnect","connect","id","documentId","traverseEntityRelations","visitor","options","data","traverseEntity","utils","attribute","type","useJoinTable","mapRelationCurried","curry","traverseEntityRelationsCurried"],"mappings":"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"}

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

@@ -11,5 +11,11 @@ export type LongHandDocument = {
     position?: object;
 };
 export type LongHand = LongHandEntity | LongHandDocument;
+export type RelationPrimitives = ShortHand | LongHand | ShortHand[] | LongHand[] | null | undefined;
+export type Relation = RelationPrimitives | {
+    connect?: RelationPrimitives;
+    disconnect?: RelationPrimitives;
+    set?: RelationPrimitives;
+};
 export type GetIds = (relation: ID) => ID[] | null;
 //# sourceMappingURL=types.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../src/services/document-service/transform/relations/utils/types.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,EAAE,GAAG,MAAM,GAAG,MAAM,CAAC;AACjC,MAAM,MAAM,SAAS,GAAG,EAAE,CAAC;AAE3B,MAAM,MAAM,cAAc,GAAG;IAAE,EAAE,EAAE,EAAE,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAC3D,MAAM,MAAM,gBAAgB,GAAG;IAC7B,UAAU,EAAE,EAAE,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,OAAO,GAAG,WAAW,CAAC;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AACF,MAAM,MAAM,QAAQ,GAAG,cAAc,GAAG,gBAAgB,CAAC;AAEzD,MAAM,MAAM,MAAM,GAAG,CAAC,QAAQ,EAAE,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../src/services/document-service/transform/relations/utils/types.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,EAAE,GAAG,MAAM,GAAG,MAAM,CAAC;AACjC,MAAM,MAAM,SAAS,GAAG,EAAE,CAAC;AAE3B,MAAM,MAAM,cAAc,GAAG;IAAE,EAAE,EAAE,EAAE,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAC3D,MAAM,MAAM,gBAAgB,GAAG;IAC7B,UAAU,EAAE,EAAE,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,OAAO,GAAG,WAAW,CAAC;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG,cAAc,GAAG,gBAAgB,CAAC;AACzD,MAAM,MAAM,kBAAkB,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS,EAAE,GAAG,QAAQ,EAAE,GAAG,IAAI,GAAG,SAAS,CAAC;AACpG,MAAM,MAAM,QAAQ,GAChB,kBAAkB,GAClB;IAAE,OAAO,CAAC,EAAE,kBAAkB,CAAC;IAAC,UAAU,CAAC,EAAE,kBAAkB,CAAC;IAAC,GAAG,CAAC,EAAE,kBAAkB,CAAA;CAAE,CAAC;AAEhG,MAAM,MAAM,MAAM,GAAG,CAAC,QAAQ,EAAE,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,CAAC"}

package/dist/services/document-service/transform/types.d.ts

@@ -1,12 +1,12 @@
-import { Common } from '@strapi/types';
-import { type ID } from './relations/utils/types';
+import type { UID } from '@strapi/types';
+import type { ID } from './relations/utils/types';
 export type Data = {
     id?: ID | object;
     documentId?: ID | object;
     [key: string]: any;
 };
 export type Options = {
-    uid: Common.UID.Schema;
+    uid: UID.Schema;
     locale?: string | null;
     status: 'draft' | 'published';
 };

package/dist/services/document-service/transform/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/services/document-service/transform/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACvC,OAAO,EAAE,KAAK,EAAE,EAAE,MAAM,yBAAyB,CAAC;AAElD,MAAM,MAAM,IAAI,GAAG;IACjB,EAAE,CAAC,EAAE,EAAE,GAAG,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,EAAE,GAAG,MAAM,CAAC;IACzB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,OAAO,GAAG;IACpB,GAAG,EAAE,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC;IACvB,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,MAAM,EAAE,OAAO,GAAG,WAAW,CAAC;CAC/B,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/services/document-service/transform/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,yBAAyB,CAAC;AAElD,MAAM,MAAM,IAAI,GAAG;IACjB,EAAE,CAAC,EAAE,EAAE,GAAG,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,EAAE,GAAG,MAAM,CAAC;IACzB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,OAAO,GAAG;IACpB,GAAG,EAAE,GAAG,CAAC,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,MAAM,EAAE,OAAO,GAAG,WAAW,CAAC;CAC/B,CAAC"}

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

@@ -0,0 +1,95 @@
+import type { UID } from '@strapi/types';
+interface LoadContext {
+    oldVersions: {
+        id: string;
+        locale: string;
+    }[];
+    newVersions: {
+        id: string;
+        locale: string;
+    }[];
+}
+/**
+ * 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
+ */
+declare const load: (uid: UID.ContentType, { oldVersions }: LoadContext) => Promise<any>;
+/**
+ * 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
+ */
+declare const sync: (oldEntries: {
+    id: string;
+    locale: string;
+}[], newEntries: {
+    id: string;
+    locale: string;
+}[], existingRelations: {
+    joinTable: any;
+    relations: any[];
+}[]) => Promise<void>;
+export { load, sync };
+//# sourceMappingURL=bidirectional-relations.d.ts.map

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

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

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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"}