fix: prevent foreign key violations during entity merges

Author: skwowet

services/libs/data-access-layer/src/members/organizations.ts

@@ -424,15 +424,6 @@ export async function findNonIntersectingRoles(
 }
 
 export async function removeMemberRole(qx: QueryExecutor, role: IMemberOrganization) {
-  console.log(`[DEBUG removeMemberRole] Deleting role:`, {
-    id: role.id,
-    memberId: role.memberId,
-    organizationId: role.organizationId,
-    title: role.title,
-    dateStart: role.dateStart,
-    dateEnd: role.dateEnd,
-  })
-
   if (role.id) {
     await deleteAffiliationOverrides(qx, role.memberId, [role.id])
   }
@@ -461,23 +452,13 @@ export async function removeMemberRole(qx: QueryExecutor, role: IMemberOrganizat
     replacements.dateEnd = (role.dateEnd as Date).toISOString()
   }
 
-  console.log(`[DEBUG removeMemberRole] Query:`, deleteMemberRole.replace(/\s+/g, ' '))
   await qx.result(deleteMemberRole, replacements)
-  console.log(`[DEBUG removeMemberRole] Delete completed`)
 }
 
 export async function addMemberRole(
   qx: QueryExecutor,
   role: IMemberOrganization,
 ): Promise<string | undefined> {
-  console.log(`[DEBUG addMemberRole] Adding role:`, {
-    memberId: role.memberId,
-    organizationId: role.organizationId,
-    title: role.title,
-    dateStart: role.dateStart,
-    dateEnd: role.dateEnd,
-  })
-
   const query = `
         insert into "memberOrganizations" ("memberId", "organizationId", "createdAt", "updatedAt", "title", "dateStart", "dateEnd", "source")
         values ($(memberId), $(organizationId), NOW(), NOW(), $(title), $(dateStart), $(dateEnd), $(source))
@@ -493,12 +474,7 @@ export async function addMemberRole(
     source: role.source || null,
   })
 
-  if (row) {
-    console.log(`[DEBUG addMemberRole] Created with ID: ${row.id}`)
-    return row.id
-  } else {
-    console.log(`[DEBUG addMemberRole] Conflict - role already exists`)
-  }
+  return row?.id
 }
 
 async function moveRolesBetweenEntities(
@@ -508,13 +484,6 @@ async function moveRolesBetweenEntities(
   mergeStrat: IMergeStrat,
   entityType: EntityType,
 ) {
-  console.log(`[DEBUG moveRolesBetweenEntities] Starting ${entityType} merge:`, {
-    primaryId,
-    secondaryId,
-    entityIdField: mergeStrat.entityIdField,
-    intersectBasedOnField: mergeStrat.intersectBasedOnField,
-  })
-
   // first, handle members that belong to both organizations,
   // then make a full update on remaining org2 members (that doesn't belong to o1)
   const rolesForBothEntities = await findRolesBelongingToBothEntities(
@@ -528,11 +497,6 @@ async function moveRolesBetweenEntities(
   const primaryRoles = rolesForBothEntities.filter((m) => mergeStrat.entityId(m) === primaryId)
   const secondaryRoles = rolesForBothEntities.filter((m) => mergeStrat.entityId(m) === secondaryId)
 
-  console.log(`[DEBUG moveRolesBetweenEntities] Found intersecting roles:`, {
-    primaryCount: primaryRoles.length,
-    secondaryCount: secondaryRoles.length,
-  })
-
   const findAffiliationOverrides =
     entityType === EntityType.MEMBER
       ? findMemberAffiliationOverrides
@@ -541,11 +505,6 @@ async function moveRolesBetweenEntities(
   const primaryAffiliationOverrides = await findAffiliationOverrides(qx, primaryId)
   const secondaryAffiliationOverrides = await findAffiliationOverrides(qx, secondaryId)
 
-  console.log(`[DEBUG moveRolesBetweenEntities] Found affiliation overrides:`, {
-    primaryOverridesCount: primaryAffiliationOverrides.length,
-    secondaryOverridesCount: secondaryAffiliationOverrides.length,
-  })
-
   await mergeRoles(
     qx,
     primaryRoles,
@@ -564,30 +523,14 @@ async function moveRolesBetweenEntities(
     mergeStrat.intersectBasedOnField,
   )
 
-  console.log(
-    `[DEBUG moveRolesBetweenEntities] Processing ${remainingRoles.length} remaining (non-intersecting) roles`,
-  )
-
   // Process non-intersecting roles: these are roles that exist only in secondary entity
   // We need to move them to primary entity and preserve their overrides
   for (const role of remainingRoles) {
-    console.log(`[DEBUG moveRolesBetweenEntities] Processing remaining role:`, {
-      id: role.id,
-      memberId: role.memberId,
-      organizationId: role.organizationId,
-    })
-
     // Check if this role has an affiliation override
     const existingOverride = secondaryAffiliationOverrides.find(
       (o) => o.memberOrganizationId === role.id,
     )
 
-    if (existingOverride) {
-      console.log(
-        `[DEBUG moveRolesBetweenEntities] Found override for role ${role.id}, will recreate after transfer`,
-      )
-    }
-
     // Remove the old role (this will also clean up its override via removeMemberRole)
     await removeMemberRole(qx, role)
 
@@ -613,28 +556,20 @@ async function moveRolesBetweenEntities(
         )
 
         if (primaryHasPrimaryWorkExp) {
-          console.log(
-            `[DEBUG moveRolesBetweenEntities] Primary already has isPrimaryWorkExperience, setting to false`,
-          )
           overrideToApply = {
             ...existingOverride,
             isPrimaryWorkExperience: false,
           }
         }
       }
 
-      console.log(`[DEBUG moveRolesBetweenEntities] Recreating override for new role ${newRoleId}`)
       await changeOverride(qx, {
         ...overrideToApply,
         memberId: mergeStrat.targetMemberId(role),
         memberOrganizationId: newRoleId,
       })
     }
   }
-
-  console.log(`[DEBUG moveRolesBetweenEntities] Non-intersecting roles processed:`, {
-    totalProcessed: remainingRoles.length,
-  })
 }
 
 export async function moveMembersBetweenOrganizations(
@@ -673,19 +608,6 @@ export async function mergeRoles(
   secondaryAffiliationOverrides: IMemberOrganizationAffiliationOverride[],
   mergeStrat: IMergeStrat,
 ) {
-  console.log(
-    `[DEBUG mergeRoles] Starting with ${primaryRoles.length} primary, ${secondaryRoles.length} secondary roles`,
-  )
-  console.log(
-    `[DEBUG mergeRoles] Secondary affiliation overrides:`,
-    secondaryAffiliationOverrides.map((o) => ({
-      id: o.id,
-      memberOrganizationId: o.memberOrganizationId,
-      allowAffiliation: o.allowAffiliation,
-      isPrimaryWorkExperience: o.isPrimaryWorkExperience,
-    })),
-  )
-
   const allExistingOverrides = [...primaryAffiliationOverrides, ...secondaryAffiliationOverrides]
   const removeRoles: IMemberOrganization[] = []
   const addRoles: (IMemberOrganization & { originalRoleId?: string })[] = []
@@ -696,34 +618,21 @@ export async function mergeRoles(
 
   // Phase 1: Analyze all secondary roles and build the complete plan
   for (const memberOrganization of secondaryRoles) {
-    console.log(`[DEBUG] Processing secondary role:`, {
-      id: memberOrganization.id,
-      memberId: memberOrganization.memberId,
-      organizationId: memberOrganization.organizationId,
-      title: memberOrganization.title,
-      dateStart: memberOrganization.dateStart,
-      dateEnd: memberOrganization.dateEnd,
-    })
-
     // if dateEnd and dateStart isn't available, we don't need to move but delete it from org2
     if (memberOrganization.dateStart === null && memberOrganization.dateEnd === null) {
-      console.log(`[DEBUG] Role has no dates - adding to removeRoles`)
       removeRoles.push(memberOrganization)
     }
     // it's a current role, also check org1 to see which one starts earlier
     else if (memberOrganization.dateStart !== null && memberOrganization.dateEnd === null) {
-      console.log(`[DEBUG] Role is current (no end date) - checking for conflicts`)
       const currentRoles = primaryRoles.filter(
         (mo) =>
           mergeStrat.worthMerging(mo, memberOrganization) &&
           mo.dateStart !== null &&
           mo.dateEnd === null,
       )
-      console.log(`[DEBUG] Found ${currentRoles.length} current roles in primary`)
 
       if (currentRoles.length === 0) {
         // no current role in org1, add the memberOrganization to org1
-        console.log(`[DEBUG] No current role conflict - will move role to primary entity`)
 
         const transformedRole = {
           title: memberOrganization.title,
@@ -735,14 +644,6 @@ export async function mergeRoles(
           originalRoleId: memberOrganization.id, // Track which secondary role this came from
         }
 
-        console.log(`[DEBUG] Transformed role:`, {
-          originalRoleId: memberOrganization.id,
-          originalMemberId: memberOrganization.memberId,
-          originalOrgId: memberOrganization.organizationId,
-          newMemberId: transformedRole.memberId,
-          newOrgId: transformedRole.organizationId,
-        })
-
         // Add transformed role to primary entity
         addRoles.push(transformedRole)
         // Remove the original role from secondary entity
@@ -766,10 +667,8 @@ export async function mergeRoles(
         }
 
         // delete role from org2
-        console.log(`[DEBUG] Removing secondary current role from removeRoles`)
         removeRoles.push(memberOrganization)
       } else {
-        console.log(`[DEBUG] ERROR: Multiple current roles found`)
         throw new Error(`Member ${memberOrganization.memberId} has more than one current roles.`)
       }
     } else if (memberOrganization.dateStart === null && memberOrganization.dateEnd !== null) {
@@ -824,15 +723,12 @@ export async function mergeRoles(
   }
 
   // Phase 2: Execute batch removal of roles
-  // Note: removeMemberRole handles override cleanup automatically
-  console.log(`[DEBUG] === REMOVE PHASE: ${removeRoles.length} roles ===`)
   for (const removeRole of removeRoles) {
     // Track if this role has an override that we need to recreate later
     const existingOverride = allExistingOverrides.find(
       (o) => o.memberOrganizationId === removeRole.id,
     )
 
-    console.log(`[DEBUG] Removing role ${removeRole.id}, has override: ${!!existingOverride}`)
     if (existingOverride) {
       // Store the override so we can recreate it for the new merged role
       affiliationOverridesToRecreate.push({
@@ -846,29 +742,12 @@ export async function mergeRoles(
   }
 
   // Phase 3: Execute batch addition of roles and recreate overrides
-  console.log(`[DEBUG] === ADD PHASE: ${addRoles.length} roles ===`)
   for (const addRole of addRoles) {
-    console.log(`[DEBUG addMemberRole] Adding role:`, {
-      memberId: addRole.memberId,
-      organizationId: addRole.organizationId,
-      title: addRole.title,
-      dateStart: addRole.dateStart,
-      dateEnd: addRole.dateEnd,
-    })
-
     const newRoleId = await addMemberRole(qx, addRole)
 
     if (newRoleId) {
       // Role was successfully created, apply affiliation overrides
       // Find overrides by matching the original role ID if available, otherwise fallback to member + title matching
-      console.log(`[DEBUG] Looking for overrides to apply to new role ${newRoleId}:`, {
-        addRoleMemberId: addRole.memberId,
-        addRoleOrgId: addRole.organizationId,
-        addRoleTitle: addRole.title,
-        originalRoleId: addRole.originalRoleId,
-        availableOverrides: affiliationOverridesToRecreate.length,
-      })
-
       const relevantOverrides = affiliationOverridesToRecreate.filter((item) => {
         // If we tracked the original role ID, use exact matching
         if (addRole.originalRoleId) {
@@ -878,8 +757,6 @@ export async function mergeRoles(
         return item.role.memberId === addRole.memberId && item.role.title === addRole.title
       })
 
-      console.log(`[DEBUG] Found ${relevantOverrides.length} relevant overrides for new role`)
-
       let overrideToApply: IMemberOrganizationAffiliationOverride | undefined
       if (relevantOverrides.length > 0) {
         // Prefer the override from the primary role if it exists
@@ -889,15 +766,9 @@ export async function mergeRoles(
 
         // If we found a primary override, use it, otherwise, use the first one
         overrideToApply = primaryOverride?.override || relevantOverrides[0]?.override
-        console.log(`[DEBUG] Selected override:`, {
-          isPrimary: !!primaryOverride,
-          allowAffiliation: overrideToApply.allowAffiliation,
-          isPrimaryWorkExperience: overrideToApply.isPrimaryWorkExperience,
-        })
       }
 
       if (overrideToApply) {
-        console.log(`[DEBUG] Applying override to new role ${newRoleId}`)
         await changeOverride(qx, {
           ...overrideToApply,
           memberId: mergeStrat.targetMemberId(addRole),
@@ -906,7 +777,6 @@ export async function mergeRoles(
       }
     } else {
       // Role already exists (duplicate), need to transfer override to existing role
-      console.log(`[DEBUG addMemberRole] Conflict - role already exists, looking for existing role`)
 
       // Find the existing role in primary that matches this addRole
       const existingPrimaryRole = primaryRoles.find(
@@ -925,18 +795,8 @@ export async function mergeRoles(
       )
 
       if (existingPrimaryRole) {
-        console.log(
-          `[DEBUG] Found existing primary role ${existingPrimaryRole.id}, transferring overrides`,
-        )
-
         // Find overrides from secondary roles that should be transferred
         // Use original role ID if available for exact matching
-        console.log(`[DEBUG] Looking for overrides to transfer (duplicate case):`, {
-          addRoleOriginalId: addRole.originalRoleId,
-          addRoleMemberId: addRole.memberId,
-          addRoleTitle: addRole.title,
-        })
-
         const secondaryOverridesToTransfer = affiliationOverridesToRecreate.filter((item) => {
           const isSecondaryOverride = secondaryAffiliationOverrides.some(
             (so) => so.memberOrganizationId === item.role.id,
@@ -953,10 +813,6 @@ export async function mergeRoles(
           return item.role.memberId === addRole.memberId && item.role.title === addRole.title
         })
 
-        console.log(
-          `[DEBUG] Found ${secondaryOverridesToTransfer.length} secondary overrides to transfer`,
-        )
-
         // Also check if there's a direct override on the secondary role we're trying to add
         const directSecondaryOverride = secondaryAffiliationOverrides.find((so) =>
           secondaryRoles.some(
@@ -1011,7 +867,6 @@ export async function mergeRoles(
             }
           }
 
-          console.log(`[DEBUG] Applying merged override to existing role ${existingPrimaryRole.id}`)
           await changeOverride(qx, {
             ...finalOverride,
             memberId: existingPrimaryRole.memberId,