@strapi/core 0.0.0-experimental.eba25ec571b091c6bde1104eb6c753debdf15462 → 0.0.0-experimental.ed76b5e1c1d6fb3b4435c438af7398a06b511d6f

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

@@ -1,69 +1,171 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const fp = require("lodash/fp");
-const load = async (uid, { oldVersions, newVersions }) => {
-  const updates = [];
-  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)) {
-        if (attribute.type !== "relation" || attribute.target !== uid || attribute.inversedBy || attribute.mappedBy) {
-          continue;
-        }
-        const joinTable = attribute.joinTable;
-        if (!joinTable) {
-          continue;
-        }
-        const { name: sourceColumnName } = joinTable.joinColumn;
-        const { name: targetColumnName } = joinTable.inverseJoinColumn;
-        const ids = oldVersions.map((entry) => entry.id);
-        const oldVersionsRelations = await strapi.db.getConnection().select("*").from(joinTable.name).whereIn(targetColumnName, ids).transacting(trx);
-        if (oldVersionsRelations.length > 0) {
-          updates.push({ joinTable, relations: oldVersionsRelations });
-        }
-        if (!model.options?.draftAndPublish) {
-          const ids2 = newVersions.map((entry) => entry.id);
-          const newVersionsRelations = await strapi.db.getConnection().select("*").from(joinTable.name).whereIn(targetColumnName, ids2).transacting(trx);
-          if (newVersionsRelations.length > 0) {
-            const discardToAdd = newVersionsRelations.filter((relation) => {
-              const matchingOldVerion = oldVersionsRelations.find((oldRelation) => {
-                return oldRelation[sourceColumnName] === relation[sourceColumnName];
-              });
-              return !matchingOldVerion;
-            }).map(fp.omit("id"));
-            updates.push({ joinTable, relations: discardToAdd });
-          }
+'use strict';
+
+var fp = require('lodash/fp');
+
+/* -------------------------------------------------------------------------------------------------
+ * Component Helper Functions
+ * -----------------------------------------------------------------------------------------------*/ /**
+ * Finds content types that contain the given component and have draft & publish enabled.
+ */ const getParentSchemasForComponent = (componentSchema)=>{
+    return Object.values(strapi.contentTypes).filter((contentType)=>{
+        if (!contentType.options?.draftAndPublish) return false;
+        return Object.values(contentType.attributes).some((attr)=>{
+            return attr.type === 'component' && attr.component === componentSchema.uid || attr.type === 'dynamiczone' && attr.components?.includes(componentSchema.uid);
+        });
+    });
+};
+/**
+ * Determines if a component relation should be propagated to a new document version
+ * when a document with draft and publish is updated.
+ */ const shouldPropagateRelationToNewVersion = async (componentRelation, componentSchema, parentSchemasForComponent, trx)=>{
+    const componentId = componentRelation[`${componentSchema.modelName}_id`];
+    const parent = await strapi.db.findComponentParent(componentSchema, componentId, parentSchemasForComponent, {
+        trx
+    });
+    // Keep relation if component has no parent entry
+    if (!parent?.uid) {
+        return true;
+    }
+    const parentContentType = strapi.contentTypes[parent.uid];
+    // Keep relation if parent doesn't have draft & publish enabled
+    if (!parentContentType?.options?.draftAndPublish) {
+        return true;
+    }
+    // Discard relation if parent has draft & publish enabled
+    return false;
+};
+/**
+ * Filters component relations to only include those that should be propagated to new document versions.
+ * Only relations that are NOT linked to a draft & publish parent type are kept.
+ */ const filterComponentRelations = async (relations, componentSchema, trx)=>{
+    // Exit if no relations to filter
+    if (relations.length === 0) {
+        return relations;
+    }
+    const componentParents = getParentSchemasForComponent(componentSchema);
+    // Exit if no draft & publish parent types exist
+    if (componentParents.length === 0) {
+        return relations;
+    }
+    const relationsToPropagate = [];
+    for (const relation of relations){
+        if (await shouldPropagateRelationToNewVersion(relation, componentSchema, componentParents, trx)) {
+            relationsToPropagate.push(relation);
         }
-      }
     }
-  });
-  return updates;
+    return relationsToPropagate;
+};
+/**
+ * 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 updates = [];
+    // Iterate all components and content types to find relations that need to be updated
+    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)){
+                /**
+         * Only consider unidirectional relations
+         */ if (attribute.type !== 'relation' || attribute.target !== uid || attribute.inversedBy || attribute.mappedBy) {
+                    continue;
+                }
+                // TODO: joinColumn relations
+                const joinTable = attribute.joinTable;
+                if (!joinTable) {
+                    continue;
+                }
+                const { name: sourceColumnName } = joinTable.joinColumn;
+                const { name: targetColumnName } = joinTable.inverseJoinColumn;
+                /**
+         * Load all relations that need to be updated
+         */ // NOTE: when the model has draft and publish, we can assume relation are only draft to draft & published to published
+                const ids = oldVersions.map((entry)=>entry.id);
+                const oldVersionsRelations = await strapi.db.getConnection().select('*').from(joinTable.name).whereIn(targetColumnName, ids).transacting(trx);
+                if (oldVersionsRelations.length > 0) {
+                    updates.push({
+                        joinTable,
+                        relations: oldVersionsRelations
+                    });
+                }
+                /**
+         * if publishing
+         *  if published version exists
+         *    updated published versions links
+         *  else
+         *    create link to newly published version
+         *
+         * if discarding
+         *    if published version link exists & not draft version link
+         *       create link to new draft version
+         */ if (!model.options?.draftAndPublish) {
+                    const ids = newVersions.map((entry)=>entry.id);
+                    // This is the step were we query the join table based on the id of the document
+                    const newVersionsRelations = await strapi.db.getConnection().select('*').from(joinTable.name).whereIn(targetColumnName, ids).transacting(trx);
+                    const filteredRelations = model.modelType === 'component' ? await filterComponentRelations(newVersionsRelations, model, trx) : newVersionsRelations;
+                    if (filteredRelations.length > 0) {
+                        // when publishing a draft that doesn't have a published version yet,
+                        // copy the links to the draft over to the published version
+                        // when discarding a published version, if no drafts exists
+                        const discardToAdd = filteredRelations.filter((relation)=>{
+                            const matchingOldVersion = oldVersionsRelations.find((oldRelation)=>{
+                                return oldRelation[sourceColumnName] === relation[sourceColumnName];
+                            });
+                            return !matchingOldVersion;
+                        }).map(fp.omit('id'));
+                        updates.push({
+                            joinTable,
+                            relations: discardToAdd
+                        });
+                    }
+                }
+            }
+        }
+    });
+    return updates;
 };
-const sync = async (oldEntries, newEntries, oldRelations) => {
-  const newEntryByLocale = fp.keyBy("locale", newEntries);
-  const oldEntriesMap = oldEntries.reduce(
-    (acc, entry) => {
-      const newEntry = newEntryByLocale[entry.locale];
-      if (!newEntry)
+/**
+ * Updates uni directional relations to target the right entries when overriding published or draft entries.
+ *
+ * @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)=>{
+    /**
+   * Create a map of old entry ids to new entry ids
+   *
+   * Will be used to update the relation target ids
+   */ const newEntryByLocale = fp.keyBy('locale', newEntries);
+    const oldEntriesMap = oldEntries.reduce((acc, entry)=>{
+        const newEntry = newEntryByLocale[entry.locale];
+        if (!newEntry) return acc;
+        acc[entry.id] = newEntry.id;
         return acc;
-      acc[entry.id] = newEntry.id;
-      return acc;
-    },
-    {}
-  );
-  await strapi.db.transaction(async ({ trx }) => {
-    for (const { joinTable, relations } of oldRelations) {
-      const column = joinTable.inverseJoinColumn.name;
-      const newRelations = relations.map((relation) => {
-        const newId = oldEntriesMap[relation[column]];
-        return { ...relation, [column]: newId };
-      });
-      await trx.batchInsert(joinTable.name, newRelations, 1e3);
-    }
-  });
+    }, {});
+    await strapi.db.transaction(async ({ trx })=>{
+        // Iterate old relations that are deleted and insert the new ones
+        for (const { joinTable, relations } of oldRelations){
+            // Update old ids with the new ones
+            const column = joinTable.inverseJoinColumn.name;
+            const newRelations = relations.map((relation)=>{
+                const newId = oldEntriesMap[relation[column]];
+                return {
+                    ...relation,
+                    [column]: newId
+                };
+            });
+            // Insert those relations into the join table
+            await trx.batchInsert(joinTable.name, newRelations, 1000);
+        }
+    });
 };
+
 exports.load = load;
 exports.sync = sync;
 //# sourceMappingURL=unidirectional-relations.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"unidirectional-relations.js","sources":["../../../../src/services/document-service/utils/unidirectional-relations.ts"],"sourcesContent":["/* eslint-disable no-continue */\nimport { keyBy, omit } from 'lodash/fp';\n\nimport { 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 lingering relations that need to be updated when overriding a published or draft entry.\n * This is necessary because the relations are uni-directional and the target entry is not aware of the source entry.\n * This is not the case for bi-directional relations, where the target entry is also linked to the source entry.\n */\nconst load = async (uid: UID.ContentType, { oldVersions, newVersions }: LoadContext) => {\n  const updates = [] as any;\n\n  // Iterate all components and content types to find relations that need to be updated\n  await strapi.db.transaction(async ({ trx }) => {\n    const contentTypes = Object.values(strapi.contentTypes) as Schema.ContentType[];\n    const components = Object.values(strapi.components) as Schema.Component[];\n\n    for (const model of [...contentTypes, ...components]) {\n      const dbModel = strapi.db.metadata.get(model.uid);\n\n      for (const attribute of Object.values(dbModel.attributes) as any) {\n        /**\n         * Only consider unidirectional relations\n         */\n        if (\n          attribute.type !== 'relation' ||\n          attribute.target !== uid ||\n          attribute.inversedBy ||\n          attribute.mappedBy\n        ) {\n          continue;\n        }\n\n        // TODO: joinColumn relations\n        const joinTable = attribute.joinTable;\n        if (!joinTable) {\n          continue;\n        }\n\n        const { name: sourceColumnName } = joinTable.joinColumn;\n        const { name: targetColumnName } = joinTable.inverseJoinColumn;\n\n        /**\n         * Load all relations that need to be updated\n         */\n        // NOTE: when the model has draft and publish, we can assume relation are only draft to draft & published to published\n        const ids = oldVersions.map((entry) => entry.id);\n\n        const oldVersionsRelations = await strapi.db\n          .getConnection()\n          .select('*')\n          .from(joinTable.name)\n          .whereIn(targetColumnName, ids)\n          .transacting(trx);\n\n        if (oldVersionsRelations.length > 0) {\n          updates.push({ joinTable, relations: oldVersionsRelations });\n        }\n\n        /**\n         * if publishing\n         *  if published version exists\n         *    updated published versions links\n         *  else\n         *    create link to newly published version\n         *\n         * if discarding\n         *    if published version link exists & not draft version link\n         *       create link to new draft version\n         */\n\n        if (!model.options?.draftAndPublish) {\n          const ids = newVersions.map((entry) => entry.id);\n\n          const newVersionsRelations = await strapi.db\n            .getConnection()\n            .select('*')\n            .from(joinTable.name)\n            .whereIn(targetColumnName, ids)\n            .transacting(trx);\n\n          if (newVersionsRelations.length > 0) {\n            // when publishing a draft that doesn't have a published version yet,\n            // copy the links to the draft over to the published version\n            // when discarding a published version, if no drafts exists\n            const discardToAdd = newVersionsRelations\n              .filter((relation) => {\n                const matchingOldVerion = oldVersionsRelations.find((oldRelation) => {\n                  return oldRelation[sourceColumnName] === relation[sourceColumnName];\n                });\n\n                return !matchingOldVerion;\n              })\n              .map(omit('id'));\n\n            updates.push({ joinTable, relations: discardToAdd });\n          }\n        }\n      }\n    }\n  });\n\n  return updates;\n};\n\n/**\n * Updates uni directional relations to target the right entries when overriding published or draft entries.\n *\n * @param oldEntries The old entries that are being overridden\n * @param newEntries The new entries that are overriding the old ones\n * @param oldRelations The relations that were previously loaded with `load` @see load\n */\nconst sync = async (\n  oldEntries: { id: string; locale: string }[],\n  newEntries: { id: string; locale: string }[],\n  oldRelations: { joinTable: any; relations: any[] }[]\n) => {\n  /**\n   * Create a map of old entry ids to new entry ids\n   *\n   * Will be used to update the relation target ids\n   */\n  const newEntryByLocale = keyBy('locale', newEntries);\n  const oldEntriesMap = oldEntries.reduce(\n    (acc, entry) => {\n      const newEntry = newEntryByLocale[entry.locale];\n      if (!newEntry) return acc;\n      acc[entry.id] = newEntry.id;\n      return acc;\n    },\n    {} as Record<string, string>\n  );\n\n  await strapi.db.transaction(async ({ trx }) => {\n    // Iterate old relations that are deleted and insert the new ones\n    for (const { joinTable, relations } of oldRelations) {\n      // Update old ids with the new ones\n      const column = joinTable.inverseJoinColumn.name;\n\n      const newRelations = relations.map((relation) => {\n        const newId = oldEntriesMap[relation[column]];\n        return { ...relation, [column]: newId };\n      });\n\n      // Insert those relations into the join table\n      await trx.batchInsert(joinTable.name, newRelations, 1000);\n    }\n  });\n};\n\nexport { load, sync };\n"],"names":["ids","omit","keyBy"],"mappings":";;;AAeA,MAAM,OAAO,OAAO,KAAsB,EAAE,aAAa,kBAA+B;AACtF,QAAM,UAAU,CAAA;AAGhB,QAAM,OAAO,GAAG,YAAY,OAAO,EAAE,UAAU;AAC7C,UAAM,eAAe,OAAO,OAAO,OAAO,YAAY;AACtD,UAAM,aAAa,OAAO,OAAO,OAAO,UAAU;AAElD,eAAW,SAAS,CAAC,GAAG,cAAc,GAAG,UAAU,GAAG;AACpD,YAAM,UAAU,OAAO,GAAG,SAAS,IAAI,MAAM,GAAG;AAEhD,iBAAW,aAAa,OAAO,OAAO,QAAQ,UAAU,GAAU;AAK9D,YAAA,UAAU,SAAS,cACnB,UAAU,WAAW,OACrB,UAAU,cACV,UAAU,UACV;AACA;AAAA,QACF;AAGA,cAAM,YAAY,UAAU;AAC5B,YAAI,CAAC,WAAW;AACd;AAAA,QACF;AAEA,cAAM,EAAE,MAAM,qBAAqB,UAAU;AAC7C,cAAM,EAAE,MAAM,qBAAqB,UAAU;AAM7C,cAAM,MAAM,YAAY,IAAI,CAAC,UAAU,MAAM,EAAE;AAE/C,cAAM,uBAAuB,MAAM,OAAO,GACvC,gBACA,OAAO,GAAG,EACV,KAAK,UAAU,IAAI,EACnB,QAAQ,kBAAkB,GAAG,EAC7B,YAAY,GAAG;AAEd,YAAA,qBAAqB,SAAS,GAAG;AACnC,kBAAQ,KAAK,EAAE,WAAW,WAAW,qBAAsB,CAAA;AAAA,QAC7D;AAcI,YAAA,CAAC,MAAM,SAAS,iBAAiB;AACnC,gBAAMA,OAAM,YAAY,IAAI,CAAC,UAAU,MAAM,EAAE;AAE/C,gBAAM,uBAAuB,MAAM,OAAO,GACvC,gBACA,OAAO,GAAG,EACV,KAAK,UAAU,IAAI,EACnB,QAAQ,kBAAkBA,IAAG,EAC7B,YAAY,GAAG;AAEd,cAAA,qBAAqB,SAAS,GAAG;AAInC,kBAAM,eAAe,qBAClB,OAAO,CAAC,aAAa;AACpB,oBAAM,oBAAoB,qBAAqB,KAAK,CAAC,gBAAgB;AACnE,uBAAO,YAAY,gBAAgB,MAAM,SAAS,gBAAgB;AAAA,cAAA,CACnE;AAED,qBAAO,CAAC;AAAA,YACT,CAAA,EACA,IAAIC,QAAK,IAAI,CAAC;AAEjB,oBAAQ,KAAK,EAAE,WAAW,WAAW,aAAc,CAAA;AAAA,UACrD;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,EAAA,CACD;AAEM,SAAA;AACT;AASA,MAAM,OAAO,OACX,YACA,YACA,iBACG;AAMG,QAAA,mBAAmBC,GAAAA,MAAM,UAAU,UAAU;AACnD,QAAM,gBAAgB,WAAW;AAAA,IAC/B,CAAC,KAAK,UAAU;AACR,YAAA,WAAW,iBAAiB,MAAM,MAAM;AAC9C,UAAI,CAAC;AAAiB,eAAA;AAClB,UAAA,MAAM,EAAE,IAAI,SAAS;AAClB,aAAA;AAAA,IACT;AAAA,IACA,CAAC;AAAA,EAAA;AAGH,QAAM,OAAO,GAAG,YAAY,OAAO,EAAE,UAAU;AAE7C,eAAW,EAAE,WAAW,UAAU,KAAK,cAAc;AAE7C,YAAA,SAAS,UAAU,kBAAkB;AAE3C,YAAM,eAAe,UAAU,IAAI,CAAC,aAAa;AAC/C,cAAM,QAAQ,cAAc,SAAS,MAAM,CAAC;AAC5C,eAAO,EAAE,GAAG,UAAU,CAAC,MAAM,GAAG,MAAM;AAAA,MAAA,CACvC;AAGD,YAAM,IAAI,YAAY,UAAU,MAAM,cAAc,GAAI;AAAA,IAC1D;AAAA,EAAA,CACD;AACH;;;"}
+{"version":3,"file":"unidirectional-relations.js","sources":["../../../../src/services/document-service/utils/unidirectional-relations.ts"],"sourcesContent":["/* eslint-disable no-continue */\nimport { keyBy, omit } from 'lodash/fp';\n\nimport type { UID, Schema } from '@strapi/types';\n\ninterface LoadContext {\n  oldVersions: { id: string; locale: string }[];\n  newVersions: { id: string; locale: string }[];\n}\n\ninterface JoinTable {\n  name: string;\n  joinColumn: { name: string };\n  inverseJoinColumn: { name: string };\n}\n\ninterface RelationUpdate {\n  joinTable: JoinTable;\n  relations: Record<string, any>[];\n}\n\n/* -------------------------------------------------------------------------------------------------\n * Component Helper Functions\n * -----------------------------------------------------------------------------------------------*/\n\n/**\n * Finds content types that contain the given component and have draft & publish enabled.\n */\nconst getParentSchemasForComponent = (componentSchema: Schema.Component): Schema.ContentType[] => {\n  return Object.values(strapi.contentTypes).filter((contentType: any) => {\n    if (!contentType.options?.draftAndPublish) return false;\n\n    return Object.values(contentType.attributes).some((attr: any) => {\n      return (\n        (attr.type === 'component' && attr.component === componentSchema.uid) ||\n        (attr.type === 'dynamiczone' && attr.components?.includes(componentSchema.uid))\n      );\n    });\n  });\n};\n\n/**\n * Determines if a component relation should be propagated to a new document version\n * when a document with draft and publish is updated.\n */\nconst shouldPropagateRelationToNewVersion = async (\n  componentRelation: Record<string, any>,\n  componentSchema: Schema.Component,\n  parentSchemasForComponent: Schema.ContentType[],\n  trx: any\n): Promise<boolean> => {\n  const componentId = componentRelation[`${componentSchema.modelName}_id`];\n\n  const parent = await strapi.db.findComponentParent(\n    componentSchema,\n    componentId,\n    parentSchemasForComponent,\n    { trx }\n  );\n\n  // Keep relation if component has no parent entry\n  if (!parent?.uid) {\n    return true;\n  }\n\n  const parentContentType = strapi.contentTypes[parent.uid as UID.ContentType];\n\n  // Keep relation if parent doesn't have draft & publish enabled\n  if (!parentContentType?.options?.draftAndPublish) {\n    return true;\n  }\n\n  // Discard relation if parent has draft & publish enabled\n  return false;\n};\n\n/**\n * Filters component relations to only include those that should be propagated to new document versions.\n * Only relations that are NOT linked to a draft & publish parent type are kept.\n */\nconst filterComponentRelations = async (\n  relations: Record<string, any>[],\n  componentSchema: Schema.Component,\n  trx: any\n): Promise<Record<string, any>[]> => {\n  // Exit if no relations to filter\n  if (relations.length === 0) {\n    return relations;\n  }\n\n  const componentParents = getParentSchemasForComponent(componentSchema);\n\n  // Exit if no draft & publish parent types exist\n  if (componentParents.length === 0) {\n    return relations;\n  }\n\n  const relationsToPropagate = [];\n  for (const relation of relations) {\n    if (\n      await shouldPropagateRelationToNewVersion(relation, componentSchema, componentParents, trx)\n    ) {\n      relationsToPropagate.push(relation);\n    }\n  }\n\n  return relationsToPropagate;\n};\n\n/**\n * Loads lingering relations that need to be updated when overriding a published or draft entry.\n * This is necessary because the relations are uni-directional and the target entry is not aware of the source entry.\n * This is not the case for bi-directional relations, where the target entry is also linked to the source entry.\n */\nconst load = async (\n  uid: UID.ContentType,\n  { oldVersions, newVersions }: LoadContext\n): Promise<RelationUpdate[]> => {\n  const updates: RelationUpdate[] = [];\n\n  // Iterate all components and content types to find relations that need to be updated\n  await strapi.db.transaction(async ({ trx }) => {\n    const contentTypes = Object.values(strapi.contentTypes) as Schema.ContentType[];\n    const components = Object.values(strapi.components) as Schema.Component[];\n\n    for (const model of [...contentTypes, ...components]) {\n      const dbModel = strapi.db.metadata.get(model.uid);\n\n      for (const attribute of Object.values(dbModel.attributes) as any) {\n        /**\n         * Only consider unidirectional relations\n         */\n        if (\n          attribute.type !== 'relation' ||\n          attribute.target !== uid ||\n          attribute.inversedBy ||\n          attribute.mappedBy\n        ) {\n          continue;\n        }\n\n        // TODO: joinColumn relations\n        const joinTable = attribute.joinTable;\n        if (!joinTable) {\n          continue;\n        }\n\n        const { name: sourceColumnName } = joinTable.joinColumn;\n        const { name: targetColumnName } = joinTable.inverseJoinColumn;\n\n        /**\n         * Load all relations that need to be updated\n         */\n        // NOTE: when the model has draft and publish, we can assume relation are only draft to draft & published to published\n        const ids = oldVersions.map((entry) => entry.id);\n\n        const oldVersionsRelations = await strapi.db\n          .getConnection()\n          .select('*')\n          .from(joinTable.name)\n          .whereIn(targetColumnName, ids)\n          .transacting(trx);\n\n        if (oldVersionsRelations.length > 0) {\n          updates.push({ joinTable, relations: oldVersionsRelations });\n        }\n\n        /**\n         * if publishing\n         *  if published version exists\n         *    updated published versions links\n         *  else\n         *    create link to newly published version\n         *\n         * if discarding\n         *    if published version link exists & not draft version link\n         *       create link to new draft version\n         */\n        if (!model.options?.draftAndPublish) {\n          const ids = newVersions.map((entry) => entry.id);\n\n          // This is the step were we query the join table based on the id of the document\n          const newVersionsRelations = await strapi.db\n            .getConnection()\n            .select('*')\n            .from(joinTable.name)\n            .whereIn(targetColumnName, ids)\n            .transacting(trx);\n\n          const filteredRelations =\n            model.modelType === 'component'\n              ? await filterComponentRelations(newVersionsRelations, model, trx)\n              : newVersionsRelations;\n\n          if (filteredRelations.length > 0) {\n            // when publishing a draft that doesn't have a published version yet,\n            // copy the links to the draft over to the published version\n            // when discarding a published version, if no drafts exists\n            const discardToAdd = filteredRelations\n              .filter((relation) => {\n                const matchingOldVersion = oldVersionsRelations.find((oldRelation) => {\n                  return oldRelation[sourceColumnName] === relation[sourceColumnName];\n                });\n\n                return !matchingOldVersion;\n              })\n              .map(omit('id'));\n\n            updates.push({ joinTable, relations: discardToAdd });\n          }\n        }\n      }\n    }\n  });\n\n  return updates;\n};\n\n/**\n * Updates uni directional relations to target the right entries when overriding published or draft entries.\n *\n * @param oldEntries The old entries that are being overridden\n * @param newEntries The new entries that are overriding the old ones\n * @param oldRelations The relations that were previously loaded with `load` @see load\n */\nconst sync = async (\n  oldEntries: { id: string; locale: string }[],\n  newEntries: { id: string; locale: string }[],\n  oldRelations: { joinTable: any; relations: any[] }[]\n) => {\n  /**\n   * Create a map of old entry ids to new entry ids\n   *\n   * Will be used to update the relation target ids\n   */\n  const newEntryByLocale = keyBy('locale', newEntries);\n  const oldEntriesMap = oldEntries.reduce(\n    (acc, entry) => {\n      const newEntry = newEntryByLocale[entry.locale];\n      if (!newEntry) return acc;\n      acc[entry.id] = newEntry.id;\n      return acc;\n    },\n    {} as Record<string, string>\n  );\n\n  await strapi.db.transaction(async ({ trx }) => {\n    // Iterate old relations that are deleted and insert the new ones\n    for (const { joinTable, relations } of oldRelations) {\n      // Update old ids with the new ones\n      const column = joinTable.inverseJoinColumn.name;\n\n      const newRelations = relations.map((relation) => {\n        const newId = oldEntriesMap[relation[column]];\n        return { ...relation, [column]: newId };\n      });\n\n      // Insert those relations into the join table\n      await trx.batchInsert(joinTable.name, newRelations, 1000);\n    }\n  });\n};\n\nexport { load, sync };\n"],"names":["getParentSchemasForComponent","componentSchema","Object","values","strapi","contentTypes","filter","contentType","options","draftAndPublish","attributes","some","attr","type","component","uid","components","includes","shouldPropagateRelationToNewVersion","componentRelation","parentSchemasForComponent","trx","componentId","modelName","parent","db","findComponentParent","parentContentType","filterComponentRelations","relations","length","componentParents","relationsToPropagate","relation","push","load","oldVersions","newVersions","updates","transaction","model","dbModel","metadata","get","attribute","target","inversedBy","mappedBy","joinTable","name","sourceColumnName","joinColumn","targetColumnName","inverseJoinColumn","ids","map","entry","id","oldVersionsRelations","getConnection","select","from","whereIn","transacting","newVersionsRelations","filteredRelations","modelType","discardToAdd","matchingOldVersion","find","oldRelation","omit","sync","oldEntries","newEntries","oldRelations","newEntryByLocale","keyBy","oldEntriesMap","reduce","acc","newEntry","locale","column","newRelations","newId","batchInsert"],"mappings":"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"}

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

@@ -1,69 +1,168 @@
-import { omit, keyBy } from "lodash/fp";
-const load = async (uid, { oldVersions, newVersions }) => {
-  const updates = [];
-  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)) {
-        if (attribute.type !== "relation" || attribute.target !== uid || attribute.inversedBy || attribute.mappedBy) {
-          continue;
-        }
-        const joinTable = attribute.joinTable;
-        if (!joinTable) {
-          continue;
-        }
-        const { name: sourceColumnName } = joinTable.joinColumn;
-        const { name: targetColumnName } = joinTable.inverseJoinColumn;
-        const ids = oldVersions.map((entry) => entry.id);
-        const oldVersionsRelations = await strapi.db.getConnection().select("*").from(joinTable.name).whereIn(targetColumnName, ids).transacting(trx);
-        if (oldVersionsRelations.length > 0) {
-          updates.push({ joinTable, relations: oldVersionsRelations });
-        }
-        if (!model.options?.draftAndPublish) {
-          const ids2 = newVersions.map((entry) => entry.id);
-          const newVersionsRelations = await strapi.db.getConnection().select("*").from(joinTable.name).whereIn(targetColumnName, ids2).transacting(trx);
-          if (newVersionsRelations.length > 0) {
-            const discardToAdd = newVersionsRelations.filter((relation) => {
-              const matchingOldVerion = oldVersionsRelations.find((oldRelation) => {
-                return oldRelation[sourceColumnName] === relation[sourceColumnName];
-              });
-              return !matchingOldVerion;
-            }).map(omit("id"));
-            updates.push({ joinTable, relations: discardToAdd });
-          }
-        }
-      }
+import { omit, keyBy } from 'lodash/fp';
+
+/* -------------------------------------------------------------------------------------------------
+ * Component Helper Functions
+ * -----------------------------------------------------------------------------------------------*/ /**
+ * Finds content types that contain the given component and have draft & publish enabled.
+ */ const getParentSchemasForComponent = (componentSchema)=>{
+    return Object.values(strapi.contentTypes).filter((contentType)=>{
+        if (!contentType.options?.draftAndPublish) return false;
+        return Object.values(contentType.attributes).some((attr)=>{
+            return attr.type === 'component' && attr.component === componentSchema.uid || attr.type === 'dynamiczone' && attr.components?.includes(componentSchema.uid);
+        });
+    });
+};
+/**
+ * Determines if a component relation should be propagated to a new document version
+ * when a document with draft and publish is updated.
+ */ const shouldPropagateRelationToNewVersion = async (componentRelation, componentSchema, parentSchemasForComponent, trx)=>{
+    const componentId = componentRelation[`${componentSchema.modelName}_id`];
+    const parent = await strapi.db.findComponentParent(componentSchema, componentId, parentSchemasForComponent, {
+        trx
+    });
+    // Keep relation if component has no parent entry
+    if (!parent?.uid) {
+        return true;
+    }
+    const parentContentType = strapi.contentTypes[parent.uid];
+    // Keep relation if parent doesn't have draft & publish enabled
+    if (!parentContentType?.options?.draftAndPublish) {
+        return true;
     }
-  });
-  return updates;
+    // Discard relation if parent has draft & publish enabled
+    return false;
 };
-const sync = async (oldEntries, newEntries, oldRelations) => {
-  const newEntryByLocale = keyBy("locale", newEntries);
-  const oldEntriesMap = oldEntries.reduce(
-    (acc, entry) => {
-      const newEntry = newEntryByLocale[entry.locale];
-      if (!newEntry)
-        return acc;
-      acc[entry.id] = newEntry.id;
-      return acc;
-    },
-    {}
-  );
-  await strapi.db.transaction(async ({ trx }) => {
-    for (const { joinTable, relations } of oldRelations) {
-      const column = joinTable.inverseJoinColumn.name;
-      const newRelations = relations.map((relation) => {
-        const newId = oldEntriesMap[relation[column]];
-        return { ...relation, [column]: newId };
-      });
-      await trx.batchInsert(joinTable.name, newRelations, 1e3);
+/**
+ * Filters component relations to only include those that should be propagated to new document versions.
+ * Only relations that are NOT linked to a draft & publish parent type are kept.
+ */ const filterComponentRelations = async (relations, componentSchema, trx)=>{
+    // Exit if no relations to filter
+    if (relations.length === 0) {
+        return relations;
     }
-  });
+    const componentParents = getParentSchemasForComponent(componentSchema);
+    // Exit if no draft & publish parent types exist
+    if (componentParents.length === 0) {
+        return relations;
+    }
+    const relationsToPropagate = [];
+    for (const relation of relations){
+        if (await shouldPropagateRelationToNewVersion(relation, componentSchema, componentParents, trx)) {
+            relationsToPropagate.push(relation);
+        }
+    }
+    return relationsToPropagate;
 };
-export {
-  load,
-  sync
+/**
+ * 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 updates = [];
+    // Iterate all components and content types to find relations that need to be updated
+    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)){
+                /**
+         * Only consider unidirectional relations
+         */ if (attribute.type !== 'relation' || attribute.target !== uid || attribute.inversedBy || attribute.mappedBy) {
+                    continue;
+                }
+                // TODO: joinColumn relations
+                const joinTable = attribute.joinTable;
+                if (!joinTable) {
+                    continue;
+                }
+                const { name: sourceColumnName } = joinTable.joinColumn;
+                const { name: targetColumnName } = joinTable.inverseJoinColumn;
+                /**
+         * Load all relations that need to be updated
+         */ // NOTE: when the model has draft and publish, we can assume relation are only draft to draft & published to published
+                const ids = oldVersions.map((entry)=>entry.id);
+                const oldVersionsRelations = await strapi.db.getConnection().select('*').from(joinTable.name).whereIn(targetColumnName, ids).transacting(trx);
+                if (oldVersionsRelations.length > 0) {
+                    updates.push({
+                        joinTable,
+                        relations: oldVersionsRelations
+                    });
+                }
+                /**
+         * if publishing
+         *  if published version exists
+         *    updated published versions links
+         *  else
+         *    create link to newly published version
+         *
+         * if discarding
+         *    if published version link exists & not draft version link
+         *       create link to new draft version
+         */ if (!model.options?.draftAndPublish) {
+                    const ids = newVersions.map((entry)=>entry.id);
+                    // This is the step were we query the join table based on the id of the document
+                    const newVersionsRelations = await strapi.db.getConnection().select('*').from(joinTable.name).whereIn(targetColumnName, ids).transacting(trx);
+                    const filteredRelations = model.modelType === 'component' ? await filterComponentRelations(newVersionsRelations, model, trx) : newVersionsRelations;
+                    if (filteredRelations.length > 0) {
+                        // when publishing a draft that doesn't have a published version yet,
+                        // copy the links to the draft over to the published version
+                        // when discarding a published version, if no drafts exists
+                        const discardToAdd = filteredRelations.filter((relation)=>{
+                            const matchingOldVersion = oldVersionsRelations.find((oldRelation)=>{
+                                return oldRelation[sourceColumnName] === relation[sourceColumnName];
+                            });
+                            return !matchingOldVersion;
+                        }).map(omit('id'));
+                        updates.push({
+                            joinTable,
+                            relations: discardToAdd
+                        });
+                    }
+                }
+            }
+        }
+    });
+    return updates;
+};
+/**
+ * Updates uni directional relations to target the right entries when overriding published or draft entries.
+ *
+ * @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)=>{
+    /**
+   * Create a map of old entry ids to new entry ids
+   *
+   * Will be used to update the relation target ids
+   */ const newEntryByLocale = keyBy('locale', newEntries);
+    const oldEntriesMap = oldEntries.reduce((acc, entry)=>{
+        const newEntry = newEntryByLocale[entry.locale];
+        if (!newEntry) return acc;
+        acc[entry.id] = newEntry.id;
+        return acc;
+    }, {});
+    await strapi.db.transaction(async ({ trx })=>{
+        // Iterate old relations that are deleted and insert the new ones
+        for (const { joinTable, relations } of oldRelations){
+            // Update old ids with the new ones
+            const column = joinTable.inverseJoinColumn.name;
+            const newRelations = relations.map((relation)=>{
+                const newId = oldEntriesMap[relation[column]];
+                return {
+                    ...relation,
+                    [column]: newId
+                };
+            });
+            // Insert those relations into the join table
+            await trx.batchInsert(joinTable.name, newRelations, 1000);
+        }
+    });
 };
+
+export { load, sync };
 //# sourceMappingURL=unidirectional-relations.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"unidirectional-relations.mjs","sources":["../../../../src/services/document-service/utils/unidirectional-relations.ts"],"sourcesContent":["/* eslint-disable no-continue */\nimport { keyBy, omit } from 'lodash/fp';\n\nimport { 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 lingering relations that need to be updated when overriding a published or draft entry.\n * This is necessary because the relations are uni-directional and the target entry is not aware of the source entry.\n * This is not the case for bi-directional relations, where the target entry is also linked to the source entry.\n */\nconst load = async (uid: UID.ContentType, { oldVersions, newVersions }: LoadContext) => {\n  const updates = [] as any;\n\n  // Iterate all components and content types to find relations that need to be updated\n  await strapi.db.transaction(async ({ trx }) => {\n    const contentTypes = Object.values(strapi.contentTypes) as Schema.ContentType[];\n    const components = Object.values(strapi.components) as Schema.Component[];\n\n    for (const model of [...contentTypes, ...components]) {\n      const dbModel = strapi.db.metadata.get(model.uid);\n\n      for (const attribute of Object.values(dbModel.attributes) as any) {\n        /**\n         * Only consider unidirectional relations\n         */\n        if (\n          attribute.type !== 'relation' ||\n          attribute.target !== uid ||\n          attribute.inversedBy ||\n          attribute.mappedBy\n        ) {\n          continue;\n        }\n\n        // TODO: joinColumn relations\n        const joinTable = attribute.joinTable;\n        if (!joinTable) {\n          continue;\n        }\n\n        const { name: sourceColumnName } = joinTable.joinColumn;\n        const { name: targetColumnName } = joinTable.inverseJoinColumn;\n\n        /**\n         * Load all relations that need to be updated\n         */\n        // NOTE: when the model has draft and publish, we can assume relation are only draft to draft & published to published\n        const ids = oldVersions.map((entry) => entry.id);\n\n        const oldVersionsRelations = await strapi.db\n          .getConnection()\n          .select('*')\n          .from(joinTable.name)\n          .whereIn(targetColumnName, ids)\n          .transacting(trx);\n\n        if (oldVersionsRelations.length > 0) {\n          updates.push({ joinTable, relations: oldVersionsRelations });\n        }\n\n        /**\n         * if publishing\n         *  if published version exists\n         *    updated published versions links\n         *  else\n         *    create link to newly published version\n         *\n         * if discarding\n         *    if published version link exists & not draft version link\n         *       create link to new draft version\n         */\n\n        if (!model.options?.draftAndPublish) {\n          const ids = newVersions.map((entry) => entry.id);\n\n          const newVersionsRelations = await strapi.db\n            .getConnection()\n            .select('*')\n            .from(joinTable.name)\n            .whereIn(targetColumnName, ids)\n            .transacting(trx);\n\n          if (newVersionsRelations.length > 0) {\n            // when publishing a draft that doesn't have a published version yet,\n            // copy the links to the draft over to the published version\n            // when discarding a published version, if no drafts exists\n            const discardToAdd = newVersionsRelations\n              .filter((relation) => {\n                const matchingOldVerion = oldVersionsRelations.find((oldRelation) => {\n                  return oldRelation[sourceColumnName] === relation[sourceColumnName];\n                });\n\n                return !matchingOldVerion;\n              })\n              .map(omit('id'));\n\n            updates.push({ joinTable, relations: discardToAdd });\n          }\n        }\n      }\n    }\n  });\n\n  return updates;\n};\n\n/**\n * Updates uni directional relations to target the right entries when overriding published or draft entries.\n *\n * @param oldEntries The old entries that are being overridden\n * @param newEntries The new entries that are overriding the old ones\n * @param oldRelations The relations that were previously loaded with `load` @see load\n */\nconst sync = async (\n  oldEntries: { id: string; locale: string }[],\n  newEntries: { id: string; locale: string }[],\n  oldRelations: { joinTable: any; relations: any[] }[]\n) => {\n  /**\n   * Create a map of old entry ids to new entry ids\n   *\n   * Will be used to update the relation target ids\n   */\n  const newEntryByLocale = keyBy('locale', newEntries);\n  const oldEntriesMap = oldEntries.reduce(\n    (acc, entry) => {\n      const newEntry = newEntryByLocale[entry.locale];\n      if (!newEntry) return acc;\n      acc[entry.id] = newEntry.id;\n      return acc;\n    },\n    {} as Record<string, string>\n  );\n\n  await strapi.db.transaction(async ({ trx }) => {\n    // Iterate old relations that are deleted and insert the new ones\n    for (const { joinTable, relations } of oldRelations) {\n      // Update old ids with the new ones\n      const column = joinTable.inverseJoinColumn.name;\n\n      const newRelations = relations.map((relation) => {\n        const newId = oldEntriesMap[relation[column]];\n        return { ...relation, [column]: newId };\n      });\n\n      // Insert those relations into the join table\n      await trx.batchInsert(joinTable.name, newRelations, 1000);\n    }\n  });\n};\n\nexport { load, sync };\n"],"names":["ids"],"mappings":";AAeA,MAAM,OAAO,OAAO,KAAsB,EAAE,aAAa,kBAA+B;AACtF,QAAM,UAAU,CAAA;AAGhB,QAAM,OAAO,GAAG,YAAY,OAAO,EAAE,UAAU;AAC7C,UAAM,eAAe,OAAO,OAAO,OAAO,YAAY;AACtD,UAAM,aAAa,OAAO,OAAO,OAAO,UAAU;AAElD,eAAW,SAAS,CAAC,GAAG,cAAc,GAAG,UAAU,GAAG;AACpD,YAAM,UAAU,OAAO,GAAG,SAAS,IAAI,MAAM,GAAG;AAEhD,iBAAW,aAAa,OAAO,OAAO,QAAQ,UAAU,GAAU;AAK9D,YAAA,UAAU,SAAS,cACnB,UAAU,WAAW,OACrB,UAAU,cACV,UAAU,UACV;AACA;AAAA,QACF;AAGA,cAAM,YAAY,UAAU;AAC5B,YAAI,CAAC,WAAW;AACd;AAAA,QACF;AAEA,cAAM,EAAE,MAAM,qBAAqB,UAAU;AAC7C,cAAM,EAAE,MAAM,qBAAqB,UAAU;AAM7C,cAAM,MAAM,YAAY,IAAI,CAAC,UAAU,MAAM,EAAE;AAE/C,cAAM,uBAAuB,MAAM,OAAO,GACvC,gBACA,OAAO,GAAG,EACV,KAAK,UAAU,IAAI,EACnB,QAAQ,kBAAkB,GAAG,EAC7B,YAAY,GAAG;AAEd,YAAA,qBAAqB,SAAS,GAAG;AACnC,kBAAQ,KAAK,EAAE,WAAW,WAAW,qBAAsB,CAAA;AAAA,QAC7D;AAcI,YAAA,CAAC,MAAM,SAAS,iBAAiB;AACnC,gBAAMA,OAAM,YAAY,IAAI,CAAC,UAAU,MAAM,EAAE;AAE/C,gBAAM,uBAAuB,MAAM,OAAO,GACvC,gBACA,OAAO,GAAG,EACV,KAAK,UAAU,IAAI,EACnB,QAAQ,kBAAkBA,IAAG,EAC7B,YAAY,GAAG;AAEd,cAAA,qBAAqB,SAAS,GAAG;AAInC,kBAAM,eAAe,qBAClB,OAAO,CAAC,aAAa;AACpB,oBAAM,oBAAoB,qBAAqB,KAAK,CAAC,gBAAgB;AACnE,uBAAO,YAAY,gBAAgB,MAAM,SAAS,gBAAgB;AAAA,cAAA,CACnE;AAED,qBAAO,CAAC;AAAA,YACT,CAAA,EACA,IAAI,KAAK,IAAI,CAAC;AAEjB,oBAAQ,KAAK,EAAE,WAAW,WAAW,aAAc,CAAA;AAAA,UACrD;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,EAAA,CACD;AAEM,SAAA;AACT;AASA,MAAM,OAAO,OACX,YACA,YACA,iBACG;AAMG,QAAA,mBAAmB,MAAM,UAAU,UAAU;AACnD,QAAM,gBAAgB,WAAW;AAAA,IAC/B,CAAC,KAAK,UAAU;AACR,YAAA,WAAW,iBAAiB,MAAM,MAAM;AAC9C,UAAI,CAAC;AAAiB,eAAA;AAClB,UAAA,MAAM,EAAE,IAAI,SAAS;AAClB,aAAA;AAAA,IACT;AAAA,IACA,CAAC;AAAA,EAAA;AAGH,QAAM,OAAO,GAAG,YAAY,OAAO,EAAE,UAAU;AAE7C,eAAW,EAAE,WAAW,UAAU,KAAK,cAAc;AAE7C,YAAA,SAAS,UAAU,kBAAkB;AAE3C,YAAM,eAAe,UAAU,IAAI,CAAC,aAAa;AAC/C,cAAM,QAAQ,cAAc,SAAS,MAAM,CAAC;AAC5C,eAAO,EAAE,GAAG,UAAU,CAAC,MAAM,GAAG,MAAM;AAAA,MAAA,CACvC;AAGD,YAAM,IAAI,YAAY,UAAU,MAAM,cAAc,GAAI;AAAA,IAC1D;AAAA,EAAA,CACD;AACH;"}
+{"version":3,"file":"unidirectional-relations.mjs","sources":["../../../../src/services/document-service/utils/unidirectional-relations.ts"],"sourcesContent":["/* eslint-disable no-continue */\nimport { keyBy, omit } from 'lodash/fp';\n\nimport type { UID, Schema } from '@strapi/types';\n\ninterface LoadContext {\n  oldVersions: { id: string; locale: string }[];\n  newVersions: { id: string; locale: string }[];\n}\n\ninterface JoinTable {\n  name: string;\n  joinColumn: { name: string };\n  inverseJoinColumn: { name: string };\n}\n\ninterface RelationUpdate {\n  joinTable: JoinTable;\n  relations: Record<string, any>[];\n}\n\n/* -------------------------------------------------------------------------------------------------\n * Component Helper Functions\n * -----------------------------------------------------------------------------------------------*/\n\n/**\n * Finds content types that contain the given component and have draft & publish enabled.\n */\nconst getParentSchemasForComponent = (componentSchema: Schema.Component): Schema.ContentType[] => {\n  return Object.values(strapi.contentTypes).filter((contentType: any) => {\n    if (!contentType.options?.draftAndPublish) return false;\n\n    return Object.values(contentType.attributes).some((attr: any) => {\n      return (\n        (attr.type === 'component' && attr.component === componentSchema.uid) ||\n        (attr.type === 'dynamiczone' && attr.components?.includes(componentSchema.uid))\n      );\n    });\n  });\n};\n\n/**\n * Determines if a component relation should be propagated to a new document version\n * when a document with draft and publish is updated.\n */\nconst shouldPropagateRelationToNewVersion = async (\n  componentRelation: Record<string, any>,\n  componentSchema: Schema.Component,\n  parentSchemasForComponent: Schema.ContentType[],\n  trx: any\n): Promise<boolean> => {\n  const componentId = componentRelation[`${componentSchema.modelName}_id`];\n\n  const parent = await strapi.db.findComponentParent(\n    componentSchema,\n    componentId,\n    parentSchemasForComponent,\n    { trx }\n  );\n\n  // Keep relation if component has no parent entry\n  if (!parent?.uid) {\n    return true;\n  }\n\n  const parentContentType = strapi.contentTypes[parent.uid as UID.ContentType];\n\n  // Keep relation if parent doesn't have draft & publish enabled\n  if (!parentContentType?.options?.draftAndPublish) {\n    return true;\n  }\n\n  // Discard relation if parent has draft & publish enabled\n  return false;\n};\n\n/**\n * Filters component relations to only include those that should be propagated to new document versions.\n * Only relations that are NOT linked to a draft & publish parent type are kept.\n */\nconst filterComponentRelations = async (\n  relations: Record<string, any>[],\n  componentSchema: Schema.Component,\n  trx: any\n): Promise<Record<string, any>[]> => {\n  // Exit if no relations to filter\n  if (relations.length === 0) {\n    return relations;\n  }\n\n  const componentParents = getParentSchemasForComponent(componentSchema);\n\n  // Exit if no draft & publish parent types exist\n  if (componentParents.length === 0) {\n    return relations;\n  }\n\n  const relationsToPropagate = [];\n  for (const relation of relations) {\n    if (\n      await shouldPropagateRelationToNewVersion(relation, componentSchema, componentParents, trx)\n    ) {\n      relationsToPropagate.push(relation);\n    }\n  }\n\n  return relationsToPropagate;\n};\n\n/**\n * Loads lingering relations that need to be updated when overriding a published or draft entry.\n * This is necessary because the relations are uni-directional and the target entry is not aware of the source entry.\n * This is not the case for bi-directional relations, where the target entry is also linked to the source entry.\n */\nconst load = async (\n  uid: UID.ContentType,\n  { oldVersions, newVersions }: LoadContext\n): Promise<RelationUpdate[]> => {\n  const updates: RelationUpdate[] = [];\n\n  // Iterate all components and content types to find relations that need to be updated\n  await strapi.db.transaction(async ({ trx }) => {\n    const contentTypes = Object.values(strapi.contentTypes) as Schema.ContentType[];\n    const components = Object.values(strapi.components) as Schema.Component[];\n\n    for (const model of [...contentTypes, ...components]) {\n      const dbModel = strapi.db.metadata.get(model.uid);\n\n      for (const attribute of Object.values(dbModel.attributes) as any) {\n        /**\n         * Only consider unidirectional relations\n         */\n        if (\n          attribute.type !== 'relation' ||\n          attribute.target !== uid ||\n          attribute.inversedBy ||\n          attribute.mappedBy\n        ) {\n          continue;\n        }\n\n        // TODO: joinColumn relations\n        const joinTable = attribute.joinTable;\n        if (!joinTable) {\n          continue;\n        }\n\n        const { name: sourceColumnName } = joinTable.joinColumn;\n        const { name: targetColumnName } = joinTable.inverseJoinColumn;\n\n        /**\n         * Load all relations that need to be updated\n         */\n        // NOTE: when the model has draft and publish, we can assume relation are only draft to draft & published to published\n        const ids = oldVersions.map((entry) => entry.id);\n\n        const oldVersionsRelations = await strapi.db\n          .getConnection()\n          .select('*')\n          .from(joinTable.name)\n          .whereIn(targetColumnName, ids)\n          .transacting(trx);\n\n        if (oldVersionsRelations.length > 0) {\n          updates.push({ joinTable, relations: oldVersionsRelations });\n        }\n\n        /**\n         * if publishing\n         *  if published version exists\n         *    updated published versions links\n         *  else\n         *    create link to newly published version\n         *\n         * if discarding\n         *    if published version link exists & not draft version link\n         *       create link to new draft version\n         */\n        if (!model.options?.draftAndPublish) {\n          const ids = newVersions.map((entry) => entry.id);\n\n          // This is the step were we query the join table based on the id of the document\n          const newVersionsRelations = await strapi.db\n            .getConnection()\n            .select('*')\n            .from(joinTable.name)\n            .whereIn(targetColumnName, ids)\n            .transacting(trx);\n\n          const filteredRelations =\n            model.modelType === 'component'\n              ? await filterComponentRelations(newVersionsRelations, model, trx)\n              : newVersionsRelations;\n\n          if (filteredRelations.length > 0) {\n            // when publishing a draft that doesn't have a published version yet,\n            // copy the links to the draft over to the published version\n            // when discarding a published version, if no drafts exists\n            const discardToAdd = filteredRelations\n              .filter((relation) => {\n                const matchingOldVersion = oldVersionsRelations.find((oldRelation) => {\n                  return oldRelation[sourceColumnName] === relation[sourceColumnName];\n                });\n\n                return !matchingOldVersion;\n              })\n              .map(omit('id'));\n\n            updates.push({ joinTable, relations: discardToAdd });\n          }\n        }\n      }\n    }\n  });\n\n  return updates;\n};\n\n/**\n * Updates uni directional relations to target the right entries when overriding published or draft entries.\n *\n * @param oldEntries The old entries that are being overridden\n * @param newEntries The new entries that are overriding the old ones\n * @param oldRelations The relations that were previously loaded with `load` @see load\n */\nconst sync = async (\n  oldEntries: { id: string; locale: string }[],\n  newEntries: { id: string; locale: string }[],\n  oldRelations: { joinTable: any; relations: any[] }[]\n) => {\n  /**\n   * Create a map of old entry ids to new entry ids\n   *\n   * Will be used to update the relation target ids\n   */\n  const newEntryByLocale = keyBy('locale', newEntries);\n  const oldEntriesMap = oldEntries.reduce(\n    (acc, entry) => {\n      const newEntry = newEntryByLocale[entry.locale];\n      if (!newEntry) return acc;\n      acc[entry.id] = newEntry.id;\n      return acc;\n    },\n    {} as Record<string, string>\n  );\n\n  await strapi.db.transaction(async ({ trx }) => {\n    // Iterate old relations that are deleted and insert the new ones\n    for (const { joinTable, relations } of oldRelations) {\n      // Update old ids with the new ones\n      const column = joinTable.inverseJoinColumn.name;\n\n      const newRelations = relations.map((relation) => {\n        const newId = oldEntriesMap[relation[column]];\n        return { ...relation, [column]: newId };\n      });\n\n      // Insert those relations into the join table\n      await trx.batchInsert(joinTable.name, newRelations, 1000);\n    }\n  });\n};\n\nexport { load, sync };\n"],"names":["getParentSchemasForComponent","componentSchema","Object","values","strapi","contentTypes","filter","contentType","options","draftAndPublish","attributes","some","attr","type","component","uid","components","includes","shouldPropagateRelationToNewVersion","componentRelation","parentSchemasForComponent","trx","componentId","modelName","parent","db","findComponentParent","parentContentType","filterComponentRelations","relations","length","componentParents","relationsToPropagate","relation","push","load","oldVersions","newVersions","updates","transaction","model","dbModel","metadata","get","attribute","target","inversedBy","mappedBy","joinTable","name","sourceColumnName","joinColumn","targetColumnName","inverseJoinColumn","ids","map","entry","id","oldVersionsRelations","getConnection","select","from","whereIn","transacting","newVersionsRelations","filteredRelations","modelType","discardToAdd","matchingOldVersion","find","oldRelation","omit","sync","oldEntries","newEntries","oldRelations","newEntryByLocale","keyBy","oldEntriesMap","reduce","acc","newEntry","locale","column","newRelations","newId","batchInsert"],"mappings":"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"}