@strapi/core 0.0.0-experimental.00380841fe1b29f71fe755bb387fa1f75073621b

package/dist/services/document-service/utils/clean-component-join-table.mjs

@@ -0,0 +1,143 @@
+import { getParentSchemasForComponent, findComponentParent } from '../components.mjs';
+
+/**
+ * Cleans ghost relations with publication state mismatches from a join table
+ * Uses schema-based draft/publish checking like prevention fix
+ */ const cleanComponentJoinTable = async (db, joinTableName, relation, sourceModel)=>{
+    try {
+        // Get the target model metadata
+        const targetModel = db.metadata.get(relation.target);
+        if (!targetModel) {
+            db.logger.debug(`Target model ${relation.target} not found, skipping ${joinTableName}`);
+            return 0;
+        }
+        // Check if source supports draft/publish, if it doesnt it should contain duplicate states
+        const sourceContentType = strapi.contentTypes[sourceModel.uid];
+        // It could be a model, which does not have the draftAndPublish option
+        const sourceSupportsDraftPublish = sourceContentType?.options?.draftAndPublish;
+        if (sourceContentType && !sourceSupportsDraftPublish) {
+            return 0;
+        }
+        // Check if target supports draft/publish using schema-based approach (like prevention fix)
+        const targetContentType = strapi.contentTypes[relation.target];
+        const targetSupportsDraftPublish = targetContentType?.options?.draftAndPublish || false;
+        if (!targetSupportsDraftPublish) {
+            return 0;
+        }
+        // Find entries with publication state mismatches
+        const ghostEntries = await findPublicationStateMismatches(db, joinTableName, relation, targetModel, sourceModel);
+        if (ghostEntries.length === 0) {
+            return 0;
+        }
+        // Remove ghost entries
+        await db.connection(joinTableName).whereIn('id', ghostEntries).del();
+        db.logger.debug(`Removed ${ghostEntries.length} ghost relations with publication state mismatches from ${joinTableName}`);
+        return ghostEntries.length;
+    } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        db.logger.error(`Failed to clean join table "${joinTableName}": ${errorMessage}`);
+        return 0;
+    }
+};
+const findContentTypeParentForComponentInstance = async (componentSchema, componentId)=>{
+    // Get the parent schemas that could contain this component
+    const parentSchemas = getParentSchemasForComponent(componentSchema);
+    if (parentSchemas.length === 0) {
+        // No potential parents
+        return null;
+    }
+    // Find the actual parent for THIS specific component instance
+    const parent = await findComponentParent(componentSchema, componentId, parentSchemas);
+    if (!parent) {
+        // No parent found for this component instance
+        return null;
+    }
+    if (strapi.components[parent.uid]) {
+        // If the parent is a component, we need to check its parents recursively
+        const parentComponentSchema = strapi.components[parent.uid];
+        return findContentTypeParentForComponentInstance(parentComponentSchema, parent.parentId);
+    }
+    if (strapi.contentTypes[parent.uid]) {
+        // Found a content type parent
+        return parent;
+    }
+    return null;
+};
+/**
+ * Finds join table entries with publication state mismatches
+ * Uses existing component parent detection from document service
+ */ const findPublicationStateMismatches = async (db, joinTableName, relation, targetModel, sourceModel)=>{
+    try {
+        // Get join column names using proper functions (addressing PR feedback)
+        const sourceColumn = relation.joinTable.joinColumn.name;
+        const targetColumn = relation.joinTable.inverseJoinColumn.name;
+        // Get all join entries with their target entities
+        const query = db.connection(joinTableName).select(`${joinTableName}.id as join_id`, `${joinTableName}.${sourceColumn} as source_id`, `${joinTableName}.${targetColumn} as target_id`, `${targetModel.tableName}.published_at as target_published_at`).leftJoin(targetModel.tableName, `${joinTableName}.${targetColumn}`, `${targetModel.tableName}.id`);
+        const joinEntries = await query;
+        // Group by source_id to find duplicates pointing to draft/published versions of same entity
+        const entriesBySource = {};
+        for (const entry of joinEntries){
+            const sourceId = entry.source_id;
+            if (!entriesBySource[sourceId]) {
+                entriesBySource[sourceId] = [];
+            }
+            entriesBySource[sourceId].push(entry);
+        }
+        const ghostEntries = [];
+        // Check if this is a join table (ends with _lnk)
+        const isRelationJoinTable = joinTableName.endsWith('_lnk');
+        const isComponentModel = !sourceModel.uid?.startsWith('api::') && !sourceModel.uid?.startsWith('plugin::') && sourceModel.uid?.includes('.');
+        // Check for draft/publish inconsistencies
+        for (const [sourceId, entries] of Object.entries(entriesBySource)){
+            // Skip entries with single relations
+            if (entries.length <= 1) {
+                continue;
+            }
+            // For component join tables, check if THIS specific component instance's parent supports D&P
+            if (isRelationJoinTable && isComponentModel) {
+                try {
+                    const componentSchema = strapi.components[sourceModel.uid];
+                    if (!componentSchema) {
+                        continue;
+                    }
+                    const parent = await findContentTypeParentForComponentInstance(componentSchema, sourceId);
+                    if (!parent) {
+                        continue;
+                    }
+                    // Check if THIS component instance's parent supports draft/publish
+                    const parentContentType = strapi.contentTypes[parent.uid];
+                    if (!parentContentType?.options?.draftAndPublish) {
+                        continue;
+                    }
+                // If we reach here, this component instance's parent DOES support D&P
+                // Continue to process this component instance for ghost relations
+                } catch (error) {
+                    continue;
+                }
+            }
+            // Find ghost relations (same logic as original but with improved parent checking)
+            for (const entry of entries){
+                if (entry.target_published_at === null) {
+                    // This is a draft target - find its published version
+                    const draftTarget = await db.connection(targetModel.tableName).select('document_id').where('id', entry.target_id).first();
+                    if (draftTarget) {
+                        const publishedVersion = await db.connection(targetModel.tableName).select('id', 'document_id').where('document_id', draftTarget.document_id).whereNotNull('published_at').first();
+                        if (publishedVersion) {
+                            // Check if we also have a relation to the published version
+                            const publishedRelation = entries.find((e)=>e.target_id === publishedVersion.id);
+                            if (publishedRelation) {
+                                ghostEntries.push(publishedRelation.join_id);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return ghostEntries;
+    } catch (error) {
+        return [];
+    }
+};
+
+export { cleanComponentJoinTable };
+//# sourceMappingURL=clean-component-join-table.mjs.map

package/dist/services/document-service/utils/clean-component-join-table.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"clean-component-join-table.mjs","sources":["../../../../src/services/document-service/utils/clean-component-join-table.ts"],"sourcesContent":["import type { Database } from '@strapi/database';\nimport type { Schema } from '@strapi/types';\nimport { findComponentParent, getParentSchemasForComponent } from '../components';\n\n/**\n * Cleans ghost relations with publication state mismatches from a join table\n * Uses schema-based draft/publish checking like prevention fix\n */\nexport const cleanComponentJoinTable = async (\n  db: Database,\n  joinTableName: string,\n  relation: any,\n  sourceModel: any\n): Promise<number> => {\n  try {\n    // Get the target model metadata\n    const targetModel = db.metadata.get(relation.target);\n    if (!targetModel) {\n      db.logger.debug(`Target model ${relation.target} not found, skipping ${joinTableName}`);\n      return 0;\n    }\n\n    // Check if source supports draft/publish, if it doesnt it should contain duplicate states\n    const sourceContentType = strapi.contentTypes[sourceModel.uid];\n    // It could be a model, which does not have the draftAndPublish option\n    const sourceSupportsDraftPublish = sourceContentType?.options?.draftAndPublish;\n\n    if (sourceContentType && !sourceSupportsDraftPublish) {\n      return 0;\n    }\n\n    // Check if target supports draft/publish using schema-based approach (like prevention fix)\n    const targetContentType =\n      strapi.contentTypes[relation.target as keyof typeof strapi.contentTypes];\n    const targetSupportsDraftPublish = targetContentType?.options?.draftAndPublish || false;\n\n    if (!targetSupportsDraftPublish) {\n      return 0;\n    }\n\n    // Find entries with publication state mismatches\n    const ghostEntries = await findPublicationStateMismatches(\n      db,\n      joinTableName,\n      relation,\n      targetModel,\n      sourceModel\n    );\n\n    if (ghostEntries.length === 0) {\n      return 0;\n    }\n\n    // Remove ghost entries\n    await db.connection(joinTableName).whereIn('id', ghostEntries).del();\n    db.logger.debug(\n      `Removed ${ghostEntries.length} ghost relations with publication state mismatches from ${joinTableName}`\n    );\n\n    return ghostEntries.length;\n  } catch (error) {\n    const errorMessage = error instanceof Error ? error.message : String(error);\n    db.logger.error(`Failed to clean join table \"${joinTableName}\": ${errorMessage}`);\n    return 0;\n  }\n};\n\nconst findContentTypeParentForComponentInstance = async (\n  componentSchema: Schema.Component,\n  componentId: number | string\n): Promise<{ uid: string; table: string; parentId: number | string } | null> => {\n  // Get the parent schemas that could contain this component\n  const parentSchemas = getParentSchemasForComponent(componentSchema);\n  if (parentSchemas.length === 0) {\n    // No potential parents\n    return null;\n  }\n\n  // Find the actual parent for THIS specific component instance\n  const parent = await findComponentParent(componentSchema, componentId, parentSchemas);\n  if (!parent) {\n    // No parent found for this component instance\n    return null;\n  }\n\n  if (strapi.components[parent.uid as keyof typeof strapi.components]) {\n    // If the parent is a component, we need to check its parents recursively\n    const parentComponentSchema = strapi.components[parent.uid as keyof typeof strapi.components];\n    return findContentTypeParentForComponentInstance(parentComponentSchema, parent.parentId);\n  }\n\n  if (strapi.contentTypes[parent.uid as keyof typeof strapi.contentTypes]) {\n    // Found a content type parent\n    return parent;\n  }\n\n  return null;\n};\n\n/**\n * Finds join table entries with publication state mismatches\n * Uses existing component parent detection from document service\n */\nconst findPublicationStateMismatches = async (\n  db: Database,\n  joinTableName: string,\n  relation: any,\n  targetModel: any,\n  sourceModel: any\n): Promise<number[]> => {\n  try {\n    // Get join column names using proper functions (addressing PR feedback)\n    const sourceColumn = relation.joinTable.joinColumn.name;\n    const targetColumn = relation.joinTable.inverseJoinColumn.name;\n\n    // Get all join entries with their target entities\n    const query = db\n      .connection(joinTableName)\n      .select(\n        `${joinTableName}.id as join_id`,\n        `${joinTableName}.${sourceColumn} as source_id`,\n        `${joinTableName}.${targetColumn} as target_id`,\n        `${targetModel.tableName}.published_at as target_published_at`\n      )\n      .leftJoin(\n        targetModel.tableName,\n        `${joinTableName}.${targetColumn}`,\n        `${targetModel.tableName}.id`\n      );\n\n    const joinEntries = await query;\n\n    // Group by source_id to find duplicates pointing to draft/published versions of same entity\n    const entriesBySource: { [key: string]: any[] } = {};\n    for (const entry of joinEntries) {\n      const sourceId = entry.source_id;\n      if (!entriesBySource[sourceId]) {\n        entriesBySource[sourceId] = [];\n      }\n      entriesBySource[sourceId].push(entry);\n    }\n\n    const ghostEntries: number[] = [];\n\n    // Check if this is a join table (ends with _lnk)\n    const isRelationJoinTable = joinTableName.endsWith('_lnk');\n    const isComponentModel =\n      !sourceModel.uid?.startsWith('api::') &&\n      !sourceModel.uid?.startsWith('plugin::') &&\n      sourceModel.uid?.includes('.');\n\n    // Check for draft/publish inconsistencies\n    for (const [sourceId, entries] of Object.entries(entriesBySource)) {\n      // Skip entries with single relations\n      if (entries.length <= 1) {\n        // eslint-disable-next-line no-continue\n        continue;\n      }\n\n      // For component join tables, check if THIS specific component instance's parent supports D&P\n      if (isRelationJoinTable && isComponentModel) {\n        try {\n          const componentSchema = strapi.components[sourceModel.uid] as Schema.Component;\n          if (!componentSchema) {\n            // eslint-disable-next-line no-continue\n            continue;\n          }\n\n          const parent = await findContentTypeParentForComponentInstance(componentSchema, sourceId);\n          if (!parent) {\n            continue;\n          }\n\n          // Check if THIS component instance's parent supports draft/publish\n          const parentContentType =\n            strapi.contentTypes[parent.uid as keyof typeof strapi.contentTypes];\n          if (!parentContentType?.options?.draftAndPublish) {\n            // This component instance's parent does NOT support D&P - skip cleanup\n            // eslint-disable-next-line no-continue\n            continue;\n          }\n\n          // If we reach here, this component instance's parent DOES support D&P\n          // Continue to process this component instance for ghost relations\n        } catch (error) {\n          // Skip this component instance on error\n          // eslint-disable-next-line no-continue\n          continue;\n        }\n      }\n\n      // Find ghost relations (same logic as original but with improved parent checking)\n      for (const entry of entries) {\n        if (entry.target_published_at === null) {\n          // This is a draft target - find its published version\n          const draftTarget = await db\n            .connection(targetModel.tableName)\n            .select('document_id')\n            .where('id', entry.target_id)\n            .first();\n\n          if (draftTarget) {\n            const publishedVersion = await db\n              .connection(targetModel.tableName)\n              .select('id', 'document_id')\n              .where('document_id', draftTarget.document_id)\n              .whereNotNull('published_at')\n              .first();\n\n            if (publishedVersion) {\n              // Check if we also have a relation to the published version\n              const publishedRelation = entries.find((e) => e.target_id === publishedVersion.id);\n              if (publishedRelation) {\n                ghostEntries.push(publishedRelation.join_id);\n              }\n            }\n          }\n        }\n      }\n    }\n\n    return ghostEntries;\n  } catch (error) {\n    return [];\n  }\n};\n"],"names":["cleanComponentJoinTable","db","joinTableName","relation","sourceModel","targetModel","metadata","get","target","logger","debug","sourceContentType","strapi","contentTypes","uid","sourceSupportsDraftPublish","options","draftAndPublish","targetContentType","targetSupportsDraftPublish","ghostEntries","findPublicationStateMismatches","length","connection","whereIn","del","error","errorMessage","Error","message","String","findContentTypeParentForComponentInstance","componentSchema","componentId","parentSchemas","getParentSchemasForComponent","parent","findComponentParent","components","parentComponentSchema","parentId","sourceColumn","joinTable","joinColumn","name","targetColumn","inverseJoinColumn","query","select","tableName","leftJoin","joinEntries","entriesBySource","entry","sourceId","source_id","push","isRelationJoinTable","endsWith","isComponentModel","startsWith","includes","entries","Object","parentContentType","target_published_at","draftTarget","where","target_id","first","publishedVersion","document_id","whereNotNull","publishedRelation","find","e","id","join_id"],"mappings":"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"}

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,53 @@
+import type { UID, Schema } from '@strapi/types';
+import type { JoinTable } from '@strapi/database';
+interface LoadContext {
+    oldVersions: {
+        id: string;
+        locale: string;
+    }[];
+    newVersions: {
+        id: string;
+        locale: string;
+    }[];
+}
+interface RelationUpdate {
+    joinTable: JoinTable;
+    relations: Record<string, any>[];
+}
+interface RelationFilterOptions {
+    /**
+     * Function to determine if a relation should be propagated to new document versions
+     * This replaces the hardcoded component-specific logic
+     */
+    shouldPropagateRelation?: (relation: Record<string, any>, model: Schema.Component | Schema.ContentType, trx: any) => Promise<boolean>;
+}
+/**
+ * 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.
+ */
+declare const load: (uid: UID.ContentType, { oldVersions, newVersions }: LoadContext, options?: RelationFilterOptions) => Promise<RelationUpdate[]>;
+/**
+ * Updates uni directional relations to target the right entries when overriding published or draft entries.
+ *
+ * This function:
+ * 1. Creates new relations pointing to the new entry versions
+ * 2. Precisely deletes only the old relations being replaced to prevent orphaned links
+ *
+ * @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
+ */
+declare const sync: (oldEntries: {
+    id: string;
+    locale: string;
+}[], newEntries: {
+    id: string;
+    locale: string;
+}[], oldRelations: {
+    joinTable: any;
+    relations: any[];
+}[]) => Promise<void>;
+export { load, sync };
+export type { RelationFilterOptions };
+//# sourceMappingURL=unidirectional-relations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"unidirectional-relations.d.ts","sourceRoot":"","sources":["../../../../src/services/document-service/utils/unidirectional-relations.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAEjD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAElD,UAAU,WAAW;IACnB,WAAW,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAC9C,WAAW,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CAC/C;AAED,UAAU,cAAc;IACtB,SAAS,EAAE,SAAS,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,CAAC;CAClC;AAED,UAAU,qBAAqB;IAC7B;;;OAGG;IACH,uBAAuB,CAAC,EAAE,CACxB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC7B,KAAK,EAAE,MAAM,CAAC,SAAS,GAAG,MAAM,CAAC,WAAW,EAC5C,GAAG,EAAE,GAAG,KACL,OAAO,CAAC,OAAO,CAAC,CAAC;CACvB;AAED;;;;GAIG;AACH,QAAA,MAAM,IAAI,QACH,IAAI,WAAW,gCACU,WAAW,YAChC,qBAAqB,KAC7B,QAAQ,cAAc,EAAE,CAyG1B,CAAC;AAEF;;;;;;;;;;GAUG;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,gBAC9B;IAAE,SAAS,EAAE,GAAG,CAAC;IAAC,SAAS,EAAE,GAAG,EAAE,CAAA;CAAE,EAAE,kBAiCrD,CAAC;AAEF,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;AACtB,YAAY,EAAE,qBAAqB,EAAE,CAAC"}

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

@@ -0,0 +1,131 @@
+'use strict';
+
+var fp = require('lodash/fp');
+
+/**
+ * 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 }, options = {})=>{
+    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);
+                    let versionRelations = newVersionsRelations;
+                    if (options.shouldPropagateRelation) {
+                        const relationsToPropagate = [];
+                        for (const relation of newVersionsRelations){
+                            if (await options.shouldPropagateRelation(relation, model, trx)) {
+                                relationsToPropagate.push(relation);
+                            }
+                        }
+                        versionRelations = relationsToPropagate;
+                    }
+                    if (versionRelations.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 = versionRelations.filter((relation)=>{
+                            const matchingOldVersion = oldVersionsRelations.find((oldRelation)=>{
+                                return oldRelation[sourceColumnName] === relation[sourceColumnName];
+                            });
+                            return !matchingOldVersion;
+                        }).map(fp.omit(strapi.db.metadata.identifiers.ID_COLUMN));
+                        updates.push({
+                            joinTable,
+                            relations: discardToAdd
+                        });
+                    }
+                }
+            }
+        }
+    });
+    return updates;
+};
+/**
+ * Updates uni directional relations to target the right entries when overriding published or draft entries.
+ *
+ * This function:
+ * 1. Creates new relations pointing to the new entry versions
+ * 2. Precisely deletes only the old relations being replaced to prevent orphaned links
+ *
+ * @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;
+    }, {});
+    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

@@ -0,0 +1 @@
+{"version":3,"file":"unidirectional-relations.js","sources":["../../../../src/services/document-service/utils/unidirectional-relations.ts"],"sourcesContent":["/* eslint-disable no-continue */\nimport { keyBy, omit } from 'lodash/fp';\n\nimport type { UID, Schema } from '@strapi/types';\n\nimport type { JoinTable } from '@strapi/database';\n\ninterface LoadContext {\n  oldVersions: { id: string; locale: string }[];\n  newVersions: { id: string; locale: string }[];\n}\n\ninterface RelationUpdate {\n  joinTable: JoinTable;\n  relations: Record<string, any>[];\n}\n\ninterface RelationFilterOptions {\n  /**\n   * Function to determine if a relation should be propagated to new document versions\n   * This replaces the hardcoded component-specific logic\n   */\n  shouldPropagateRelation?: (\n    relation: Record<string, any>,\n    model: Schema.Component | Schema.ContentType,\n    trx: any\n  ) => Promise<boolean>;\n}\n\n/**\n * Loads lingering relations that need to be updated when overriding a published or draft entry.\n * This is necessary because the relations are uni-directional and the target entry is not aware of the source entry.\n * This is not the case for bi-directional relations, where the target entry is also linked to the source entry.\n */\nconst load = async (\n  uid: UID.ContentType,\n  { oldVersions, newVersions }: LoadContext,\n  options: RelationFilterOptions = {}\n): Promise<RelationUpdate[]> => {\n  const updates: RelationUpdate[] = [];\n\n  // Iterate all components and content types to find relations that need to be updated\n  await strapi.db.transaction(async ({ trx }) => {\n    const contentTypes = Object.values(strapi.contentTypes) as Schema.ContentType[];\n    const components = Object.values(strapi.components) as Schema.Component[];\n\n    for (const model of [...contentTypes, ...components]) {\n      const dbModel = strapi.db.metadata.get(model.uid);\n\n      for (const attribute of Object.values(dbModel.attributes) as any) {\n        /**\n         * Only consider unidirectional relations\n         */\n        if (\n          attribute.type !== 'relation' ||\n          attribute.target !== uid ||\n          attribute.inversedBy ||\n          attribute.mappedBy\n        ) {\n          continue;\n        }\n\n        // TODO: joinColumn relations\n        const joinTable = attribute.joinTable;\n        if (!joinTable) {\n          continue;\n        }\n\n        const { name: sourceColumnName } = joinTable.joinColumn;\n        const { name: targetColumnName } = joinTable.inverseJoinColumn;\n\n        /**\n         * Load all relations that need to be updated\n         */\n        // NOTE: when the model has draft and publish, we can assume relation are only draft to draft & published to published\n        const ids = oldVersions.map((entry) => entry.id);\n\n        const oldVersionsRelations = await strapi.db\n          .getConnection()\n          .select('*')\n          .from(joinTable.name)\n          .whereIn(targetColumnName, ids)\n          .transacting(trx);\n\n        if (oldVersionsRelations.length > 0) {\n          updates.push({ joinTable, relations: oldVersionsRelations });\n        }\n\n        /**\n         * if publishing\n         *  if published version exists\n         *    updated published versions links\n         *  else\n         *    create link to newly published version\n         *\n         * if discarding\n         *    if published version link exists & not draft version link\n         *       create link to new draft version\n         */\n        if (!model.options?.draftAndPublish) {\n          const ids = newVersions.map((entry) => entry.id);\n\n          // This is the step were we query the join table based on the id of the document\n          const newVersionsRelations = await strapi.db\n            .getConnection()\n            .select('*')\n            .from(joinTable.name)\n            .whereIn(targetColumnName, ids)\n            .transacting(trx);\n\n          let versionRelations = newVersionsRelations;\n          if (options.shouldPropagateRelation) {\n            const relationsToPropagate = [];\n            for (const relation of newVersionsRelations) {\n              if (await options.shouldPropagateRelation(relation, model, trx)) {\n                relationsToPropagate.push(relation);\n              }\n            }\n            versionRelations = relationsToPropagate;\n          }\n\n          if (versionRelations.length > 0) {\n            // when publishing a draft that doesn't have a published version yet,\n            // copy the links to the draft over to the published version\n            // when discarding a published version, if no drafts exists\n            const discardToAdd = versionRelations\n              .filter((relation) => {\n                const matchingOldVersion = oldVersionsRelations.find((oldRelation) => {\n                  return oldRelation[sourceColumnName] === relation[sourceColumnName];\n                });\n\n                return !matchingOldVersion;\n              })\n              .map(omit(strapi.db.metadata.identifiers.ID_COLUMN));\n\n            updates.push({ joinTable, relations: discardToAdd });\n          }\n        }\n      }\n    }\n  });\n\n  return updates;\n};\n\n/**\n * Updates uni directional relations to target the right entries when overriding published or draft entries.\n *\n * This function:\n * 1. Creates new relations pointing to the new entry versions\n * 2. Precisely deletes only the old relations being replaced to prevent orphaned links\n *\n * @param oldEntries The old entries that are being overridden\n * @param newEntries The new entries that are overriding the old ones\n * @param oldRelations The relations that were previously loaded with `load` @see load\n */\nconst sync = async (\n  oldEntries: { id: string; locale: string }[],\n  newEntries: { id: string; locale: string }[],\n  oldRelations: { joinTable: any; relations: any[] }[]\n) => {\n  /**\n   * Create a map of old entry ids to new entry ids\n   *\n   * Will be used to update the relation target ids\n   */\n  const newEntryByLocale = keyBy('locale', newEntries);\n  const oldEntriesMap = oldEntries.reduce(\n    (acc, entry) => {\n      const newEntry = newEntryByLocale[entry.locale];\n      if (!newEntry) return acc;\n      acc[entry.id] = newEntry.id;\n      return acc;\n    },\n    {} as Record<string, string>\n  );\n\n  await strapi.db.transaction(async ({ trx }) => {\n    // Iterate old relations that are deleted and insert the new ones\n    for (const { joinTable, relations } of oldRelations) {\n      // Update old ids with the new ones\n      const column = joinTable.inverseJoinColumn.name;\n\n      const newRelations = relations.map((relation) => {\n        const newId = oldEntriesMap[relation[column]];\n        return { ...relation, [column]: newId };\n      });\n\n      // Insert those relations into the join table\n      await trx.batchInsert(joinTable.name, newRelations, 1000);\n    }\n  });\n};\n\nexport { load, sync };\nexport type { RelationFilterOptions };\n"],"names":["load","uid","oldVersions","newVersions","options","updates","strapi","db","transaction","trx","contentTypes","Object","values","components","model","dbModel","metadata","get","attribute","attributes","type","target","inversedBy","mappedBy","joinTable","name","sourceColumnName","joinColumn","targetColumnName","inverseJoinColumn","ids","map","entry","id","oldVersionsRelations","getConnection","select","from","whereIn","transacting","length","push","relations","draftAndPublish","newVersionsRelations","versionRelations","shouldPropagateRelation","relationsToPropagate","relation","discardToAdd","filter","matchingOldVersion","find","oldRelation","omit","identifiers","ID_COLUMN","sync","oldEntries","newEntries","oldRelations","newEntryByLocale","keyBy","oldEntriesMap","reduce","acc","newEntry","locale","column","newRelations","newId","batchInsert"],"mappings":"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"}