@open-mercato/core 0.6.4-develop.4210.1.d412061cfe → 0.6.4-develop.4236.1.9fa6806b34

package/src/modules/messages/commands/messages.ts

@@ -1,6 +1,7 @@
 import type { EntityManager } from '@mikro-orm/postgresql'
 import { z } from 'zod'
 import { registerCommand, type CommandHandler } from '@open-mercato/shared/lib/commands'
+import { withAtomicFlush } from '@open-mercato/shared/lib/commands/flush'
 import { extractUndoPayload, type UndoPayload } from '@open-mercato/shared/lib/commands/undo'
 import { findOneWithDecryption, findWithDecryption } from '@open-mercato/shared/lib/encryption/find'
 import { Message, MessageObject, MessageRecipient, type MessageActionData } from '../data/entities'
@@ -432,94 +433,95 @@ const updateDraftCommand: CommandHandler<unknown, { ok: true; id: string }> = {
       }
     }
 
-    if (input.type !== undefined) message.type = input.type
-    if (input.visibility !== undefined) message.visibility = input.visibility
-    if (input.sourceEntityType !== undefined) message.sourceEntityType = input.sourceEntityType
-    if (input.sourceEntityId !== undefined) message.sourceEntityId = input.sourceEntityId
-    if (input.externalEmail !== undefined) message.externalEmail = input.externalEmail
-    if (input.externalName !== undefined) message.externalName = input.externalName
-    if (input.subject !== undefined) message.subject = input.subject
-    if (input.body !== undefined) message.body = input.body
-    if (input.bodyFormat !== undefined) message.bodyFormat = input.bodyFormat
-    if (input.priority !== undefined) message.priority = input.priority
-    if (input.actionData !== undefined) message.actionData = input.actionData
-    if (input.sendViaEmail !== undefined) message.sendViaEmail = input.sendViaEmail
-
-    if (input.recipients) {
-      await em.nativeDelete(MessageRecipient, { messageId: message.id })
-      for (const recipient of input.recipients) {
-        em.persist(em.create(MessageRecipient, {
-          messageId: message.id,
-          recipientUserId: recipient.userId,
-          recipientType: recipient.type,
-          status: 'unread',
-        }))
+    await withAtomicFlush(em, [async () => {
+      if (input.type !== undefined) message.type = input.type
+      if (input.visibility !== undefined) message.visibility = input.visibility
+      if (input.sourceEntityType !== undefined) message.sourceEntityType = input.sourceEntityType
+      if (input.sourceEntityId !== undefined) message.sourceEntityId = input.sourceEntityId
+      if (input.externalEmail !== undefined) message.externalEmail = input.externalEmail
+      if (input.externalName !== undefined) message.externalName = input.externalName
+      if (input.subject !== undefined) message.subject = input.subject
+      if (input.body !== undefined) message.body = input.body
+      if (input.bodyFormat !== undefined) message.bodyFormat = input.bodyFormat
+      if (input.priority !== undefined) message.priority = input.priority
+      if (input.actionData !== undefined) message.actionData = input.actionData
+      if (input.sendViaEmail !== undefined) message.sendViaEmail = input.sendViaEmail
+
+      if (input.recipients) {
+        await em.nativeDelete(MessageRecipient, { messageId: message.id })
+        for (const recipient of input.recipients) {
+          em.persist(em.create(MessageRecipient, {
+            messageId: message.id,
+            recipientUserId: recipient.userId,
+            recipientType: recipient.type,
+            status: 'unread',
+          }))
+        }
       }
-    }
 
-    if (input.objects) {
-      await em.nativeDelete(MessageObject, { messageId: message.id })
-      for (const object of input.objects) {
-        em.persist(em.create(MessageObject, {
-          messageId: message.id,
-          entityModule: object.entityModule,
-          entityType: object.entityType,
-          entityId: object.entityId,
-          actionRequired: object.actionRequired,
-          actionType: object.actionType,
-          actionLabel: object.actionLabel,
-        }))
+      if (input.objects) {
+        await em.nativeDelete(MessageObject, { messageId: message.id })
+        for (const object of input.objects) {
+          em.persist(em.create(MessageObject, {
+            messageId: message.id,
+            entityModule: object.entityModule,
+            entityType: object.entityType,
+            entityId: object.entityId,
+            actionRequired: object.actionRequired,
+            actionType: object.actionType,
+            actionLabel: object.actionLabel,
+          }))
+        }
       }
-    }
 
-    if (input.attachmentIds) {
-      const { Attachment } = await import('@open-mercato/core/modules/attachments/data/entities')
-      if (input.attachmentIds.length === 0) {
-        await em.nativeDelete(Attachment, {
-          entityId: MESSAGE_ATTACHMENT_ENTITY_ID,
-          recordId: message.id,
-          tenantId: input.tenantId,
-          organizationId: input.organizationId,
-        })
-      } else {
-        await em.nativeDelete(Attachment, {
-          entityId: MESSAGE_ATTACHMENT_ENTITY_ID,
-          recordId: message.id,
-          tenantId: input.tenantId,
-          organizationId: input.organizationId,
-          id: { $nin: input.attachmentIds },
-        })
+      if (input.attachmentIds) {
+        const { Attachment } = await import('@open-mercato/core/modules/attachments/data/entities')
+        if (input.attachmentIds.length === 0) {
+          await em.nativeDelete(Attachment, {
+            entityId: MESSAGE_ATTACHMENT_ENTITY_ID,
+            recordId: message.id,
+            tenantId: input.tenantId,
+            organizationId: input.organizationId,
+          })
+        } else {
+          await em.nativeDelete(Attachment, {
+            entityId: MESSAGE_ATTACHMENT_ENTITY_ID,
+            recordId: message.id,
+            tenantId: input.tenantId,
+            organizationId: input.organizationId,
+            id: { $nin: input.attachmentIds },
+          })
+        }
+        await linkAttachmentsToMessage(
+          em,
+          message.id,
+          input.attachmentIds,
+          input.organizationId,
+          input.tenantId,
+        )
       }
-      await linkAttachmentsToMessage(
-        em,
-        message.id,
-        input.attachmentIds,
-        input.organizationId,
-        input.tenantId,
-      )
-    }
 
-    if (isSending) {
-      const finalVisibility = input.visibility ?? message.visibility
-      const finalSubject = input.subject ?? message.subject
-      const finalBody = input.body ?? message.body
-      const finalRecipientCount = input.recipients
-        ? input.recipients.length
-        : (preloadedRecipients?.length ?? 0)
-
-      if (finalVisibility !== 'public' && finalRecipientCount === 0) {
-        throw new Error('at least one recipient is required')
-      }
-      if (!finalSubject?.trim()) throw new Error('subject is required')
-      if (!finalBody?.trim()) throw new Error('body is required')
+      if (isSending) {
+        const finalVisibility = input.visibility ?? message.visibility
+        const finalSubject = input.subject ?? message.subject
+        const finalBody = input.body ?? message.body
+        const finalRecipientCount = input.recipients
+          ? input.recipients.length
+          : (preloadedRecipients?.length ?? 0)
 
-      message.isDraft = false
-      message.status = 'sent'
-      message.sentAt = new Date()
-      if (!message.threadId) message.threadId = message.id
-    }
+        if (finalVisibility !== 'public' && finalRecipientCount === 0) {
+          throw new Error('at least one recipient is required')
+        }
+        if (!finalSubject?.trim()) throw new Error('subject is required')
+        if (!finalBody?.trim()) throw new Error('body is required')
+
+        message.isDraft = false
+        message.status = 'sent'
+        message.sentAt = new Date()
+        if (!message.threadId) message.threadId = message.id
+      }
+    }], { transaction: true })
 
-    await em.flush()
     await emitMessageIndexUpsert(ctx.container, {
       messageId: message.id,
       tenantId: input.tenantId,

package/src/modules/messages/commands/shared.ts

@@ -1,4 +1,5 @@
 import type { EntityManager } from '@mikro-orm/postgresql'
+import { withAtomicFlush } from '@open-mercato/shared/lib/commands/flush'
 import { Message, MessageObject, MessageRecipient, type MessageActionData, type RecipientStatus } from '../data/entities'
 import { MESSAGE_ATTACHMENT_ENTITY_ID } from '../lib/constants'
 
@@ -187,152 +188,156 @@ export async function restoreMessageAggregateSnapshot(
   em: EntityManager,
   snapshot: MessageAggregateSnapshot,
 ): Promise<void> {
-  const existingMessage = await em.findOne(Message, { id: snapshot.message.id })
-  if (!existingMessage) {
-    const created = em.create(Message, {
-      id: snapshot.message.id,
-      type: snapshot.message.type,
-      visibility: snapshot.message.visibility,
-      sourceEntityType: snapshot.message.sourceEntityType,
-      sourceEntityId: snapshot.message.sourceEntityId,
-      externalEmail: snapshot.message.externalEmail,
-      externalName: snapshot.message.externalName,
-      threadId: snapshot.message.threadId,
-      parentMessageId: snapshot.message.parentMessageId,
-      senderUserId: snapshot.message.senderUserId,
-      subject: snapshot.message.subject,
-      body: snapshot.message.body,
-      bodyFormat: snapshot.message.bodyFormat,
-      priority: snapshot.message.priority,
-      status: snapshot.message.status,
-      isDraft: snapshot.message.isDraft,
-      sentAt: toDate(snapshot.message.sentAt),
-      actionData: snapshot.message.actionData as MessageActionData,
-      actionResult: snapshot.message.actionResult,
-      actionTaken: snapshot.message.actionTaken,
-      actionTakenByUserId: snapshot.message.actionTakenByUserId,
-      actionTakenAt: toDate(snapshot.message.actionTakenAt),
-      sendViaEmail: snapshot.message.sendViaEmail,
-      tenantId: snapshot.message.tenantId,
-      organizationId: snapshot.message.organizationId,
-      deletedAt: toDate(snapshot.message.deletedAt),
-    })
-    em.persist(created)
-  } else {
-    existingMessage.type = snapshot.message.type
-    existingMessage.visibility = snapshot.message.visibility
-    existingMessage.sourceEntityType = snapshot.message.sourceEntityType
-    existingMessage.sourceEntityId = snapshot.message.sourceEntityId
-    existingMessage.externalEmail = snapshot.message.externalEmail
-    existingMessage.externalName = snapshot.message.externalName
-    existingMessage.threadId = snapshot.message.threadId
-    existingMessage.parentMessageId = snapshot.message.parentMessageId
-    existingMessage.senderUserId = snapshot.message.senderUserId
-    existingMessage.subject = snapshot.message.subject
-    existingMessage.body = snapshot.message.body
-    existingMessage.bodyFormat = snapshot.message.bodyFormat
-    existingMessage.priority = snapshot.message.priority
-    existingMessage.status = snapshot.message.status
-    existingMessage.isDraft = snapshot.message.isDraft
-    existingMessage.sentAt = toDate(snapshot.message.sentAt)
-    existingMessage.actionData = snapshot.message.actionData as MessageActionData
-    existingMessage.actionResult = snapshot.message.actionResult
-    existingMessage.actionTaken = snapshot.message.actionTaken
-    existingMessage.actionTakenByUserId = snapshot.message.actionTakenByUserId
-    existingMessage.actionTakenAt = toDate(snapshot.message.actionTakenAt)
-    existingMessage.sendViaEmail = snapshot.message.sendViaEmail
-    existingMessage.tenantId = snapshot.message.tenantId
-    existingMessage.organizationId = snapshot.message.organizationId
-    existingMessage.deletedAt = toDate(snapshot.message.deletedAt)
-  }
+  await withAtomicFlush(em, [async () => {
+    // Resolve every read before mutating: a query issued between a scalar
+    // mutation and the flush can silently reset the Unit of Work (SPEC-018
+    // Problem 1). withAtomicFlush flushes once at the end, so ordering is ours.
+    const { Attachment } = await import('@open-mercato/core/modules/attachments/data/entities')
+    const existingMessage = await em.findOne(Message, { id: snapshot.message.id })
+    const existingRecipients = await em.find(MessageRecipient, { messageId: snapshot.message.id })
+    const existingObjects = await em.find(MessageObject, { messageId: snapshot.message.id })
+    const attachmentsToRelink = snapshot.attachmentIds.length > 0
+      ? await em.find(Attachment, {
+          id: { $in: snapshot.attachmentIds },
+          tenantId: snapshot.message.tenantId,
+          organizationId: snapshot.message.organizationId,
+        })
+      : []
 
-  const existingRecipients = await em.find(MessageRecipient, { messageId: snapshot.message.id })
-  const recipientById = new Map(existingRecipients.map((item) => [item.id, item]))
-  const snapshotRecipientIds = new Set(snapshot.recipients.map((item) => item.id))
-  for (const current of existingRecipients) {
-    if (!snapshotRecipientIds.has(current.id)) {
-      em.remove(current)
+    if (!existingMessage) {
+      const created = em.create(Message, {
+        id: snapshot.message.id,
+        type: snapshot.message.type,
+        visibility: snapshot.message.visibility,
+        sourceEntityType: snapshot.message.sourceEntityType,
+        sourceEntityId: snapshot.message.sourceEntityId,
+        externalEmail: snapshot.message.externalEmail,
+        externalName: snapshot.message.externalName,
+        threadId: snapshot.message.threadId,
+        parentMessageId: snapshot.message.parentMessageId,
+        senderUserId: snapshot.message.senderUserId,
+        subject: snapshot.message.subject,
+        body: snapshot.message.body,
+        bodyFormat: snapshot.message.bodyFormat,
+        priority: snapshot.message.priority,
+        status: snapshot.message.status,
+        isDraft: snapshot.message.isDraft,
+        sentAt: toDate(snapshot.message.sentAt),
+        actionData: snapshot.message.actionData as MessageActionData,
+        actionResult: snapshot.message.actionResult,
+        actionTaken: snapshot.message.actionTaken,
+        actionTakenByUserId: snapshot.message.actionTakenByUserId,
+        actionTakenAt: toDate(snapshot.message.actionTakenAt),
+        sendViaEmail: snapshot.message.sendViaEmail,
+        tenantId: snapshot.message.tenantId,
+        organizationId: snapshot.message.organizationId,
+        deletedAt: toDate(snapshot.message.deletedAt),
+      })
+      em.persist(created)
+    } else {
+      existingMessage.type = snapshot.message.type
+      existingMessage.visibility = snapshot.message.visibility
+      existingMessage.sourceEntityType = snapshot.message.sourceEntityType
+      existingMessage.sourceEntityId = snapshot.message.sourceEntityId
+      existingMessage.externalEmail = snapshot.message.externalEmail
+      existingMessage.externalName = snapshot.message.externalName
+      existingMessage.threadId = snapshot.message.threadId
+      existingMessage.parentMessageId = snapshot.message.parentMessageId
+      existingMessage.senderUserId = snapshot.message.senderUserId
+      existingMessage.subject = snapshot.message.subject
+      existingMessage.body = snapshot.message.body
+      existingMessage.bodyFormat = snapshot.message.bodyFormat
+      existingMessage.priority = snapshot.message.priority
+      existingMessage.status = snapshot.message.status
+      existingMessage.isDraft = snapshot.message.isDraft
+      existingMessage.sentAt = toDate(snapshot.message.sentAt)
+      existingMessage.actionData = snapshot.message.actionData as MessageActionData
+      existingMessage.actionResult = snapshot.message.actionResult
+      existingMessage.actionTaken = snapshot.message.actionTaken
+      existingMessage.actionTakenByUserId = snapshot.message.actionTakenByUserId
+      existingMessage.actionTakenAt = toDate(snapshot.message.actionTakenAt)
+      existingMessage.sendViaEmail = snapshot.message.sendViaEmail
+      existingMessage.tenantId = snapshot.message.tenantId
+      existingMessage.organizationId = snapshot.message.organizationId
+      existingMessage.deletedAt = toDate(snapshot.message.deletedAt)
     }
-  }
-  for (const recipient of snapshot.recipients) {
-    const existing = recipientById.get(recipient.id)
-    if (!existing) {
-      em.persist(em.create(MessageRecipient, {
-        id: recipient.id,
-        messageId: recipient.messageId,
-        recipientUserId: recipient.recipientUserId,
-        recipientType: recipient.recipientType,
-        status: recipient.status,
-        readAt: toDate(recipient.readAt),
-        archivedAt: toDate(recipient.archivedAt),
-        deletedAt: toDate(recipient.deletedAt),
-      }))
-      continue
+
+    const recipientById = new Map(existingRecipients.map((item) => [item.id, item]))
+    const snapshotRecipientIds = new Set(snapshot.recipients.map((item) => item.id))
+    for (const current of existingRecipients) {
+      if (!snapshotRecipientIds.has(current.id)) {
+        em.remove(current)
+      }
+    }
+    for (const recipient of snapshot.recipients) {
+      const existing = recipientById.get(recipient.id)
+      if (!existing) {
+        em.persist(em.create(MessageRecipient, {
+          id: recipient.id,
+          messageId: recipient.messageId,
+          recipientUserId: recipient.recipientUserId,
+          recipientType: recipient.recipientType,
+          status: recipient.status,
+          readAt: toDate(recipient.readAt),
+          archivedAt: toDate(recipient.archivedAt),
+          deletedAt: toDate(recipient.deletedAt),
+        }))
+        continue
+      }
+      existing.messageId = recipient.messageId
+      existing.recipientUserId = recipient.recipientUserId
+      existing.recipientType = recipient.recipientType
+      existing.status = recipient.status
+      existing.readAt = toDate(recipient.readAt)
+      existing.archivedAt = toDate(recipient.archivedAt)
+      existing.deletedAt = toDate(recipient.deletedAt)
     }
-    existing.messageId = recipient.messageId
-    existing.recipientUserId = recipient.recipientUserId
-    existing.recipientType = recipient.recipientType
-    existing.status = recipient.status
-    existing.readAt = toDate(recipient.readAt)
-    existing.archivedAt = toDate(recipient.archivedAt)
-    existing.deletedAt = toDate(recipient.deletedAt)
-  }
 
-  const existingObjects = await em.find(MessageObject, { messageId: snapshot.message.id })
-  const objectById = new Map(existingObjects.map((item) => [item.id, item]))
-  const snapshotObjectIds = new Set(snapshot.objects.map((item) => item.id))
-  for (const current of existingObjects) {
-    if (!snapshotObjectIds.has(current.id)) {
-      em.remove(current)
+    const objectById = new Map(existingObjects.map((item) => [item.id, item]))
+    const snapshotObjectIds = new Set(snapshot.objects.map((item) => item.id))
+    for (const current of existingObjects) {
+      if (!snapshotObjectIds.has(current.id)) {
+        em.remove(current)
+      }
     }
-  }
-  for (const object of snapshot.objects) {
-    const existing = objectById.get(object.id)
-    if (!existing) {
-      em.persist(em.create(MessageObject, {
-        id: object.id,
-        messageId: object.messageId,
-        entityModule: object.entityModule,
-        entityType: object.entityType,
-        entityId: object.entityId,
-        actionRequired: object.actionRequired,
-        actionType: object.actionType,
-        actionLabel: object.actionLabel,
-        entitySnapshot: object.entitySnapshot,
-      }))
-      continue
+    for (const object of snapshot.objects) {
+      const existing = objectById.get(object.id)
+      if (!existing) {
+        em.persist(em.create(MessageObject, {
+          id: object.id,
+          messageId: object.messageId,
+          entityModule: object.entityModule,
+          entityType: object.entityType,
+          entityId: object.entityId,
+          actionRequired: object.actionRequired,
+          actionType: object.actionType,
+          actionLabel: object.actionLabel,
+          entitySnapshot: object.entitySnapshot,
+        }))
+        continue
+      }
+      existing.messageId = object.messageId
+      existing.entityModule = object.entityModule
+      existing.entityType = object.entityType
+      existing.entityId = object.entityId
+      existing.actionRequired = object.actionRequired
+      existing.actionType = object.actionType
+      existing.actionLabel = object.actionLabel
+      existing.entitySnapshot = object.entitySnapshot
     }
-    existing.messageId = object.messageId
-    existing.entityModule = object.entityModule
-    existing.entityType = object.entityType
-    existing.entityId = object.entityId
-    existing.actionRequired = object.actionRequired
-    existing.actionType = object.actionType
-    existing.actionLabel = object.actionLabel
-    existing.entitySnapshot = object.entitySnapshot
-  }
 
-  const { Attachment } = await import('@open-mercato/core/modules/attachments/data/entities')
-  await em.nativeDelete(Attachment, {
-    entityId: MESSAGE_ATTACHMENT_ENTITY_ID,
-    recordId: snapshot.message.id,
-    tenantId: snapshot.message.tenantId,
-    organizationId: snapshot.message.organizationId,
-    id: { $nin: snapshot.attachmentIds.length > 0 ? snapshot.attachmentIds : ['00000000-0000-0000-0000-000000000000'] },
-  })
-  if (snapshot.attachmentIds.length > 0) {
-    const attachments = await em.find(Attachment, {
-      id: { $in: snapshot.attachmentIds },
+    await em.nativeDelete(Attachment, {
+      entityId: MESSAGE_ATTACHMENT_ENTITY_ID,
+      recordId: snapshot.message.id,
       tenantId: snapshot.message.tenantId,
       organizationId: snapshot.message.organizationId,
+      id: { $nin: snapshot.attachmentIds.length > 0 ? snapshot.attachmentIds : ['00000000-0000-0000-0000-000000000000'] },
     })
-    for (const attachment of attachments) {
+    for (const attachment of attachmentsToRelink) {
       attachment.entityId = MESSAGE_ATTACHMENT_ENTITY_ID
       attachment.recordId = snapshot.message.id
     }
-  }
-
-  await em.flush()
+  }], { transaction: true })
 }
 
 export function buildCommandLogBase(

package/src/modules/perspectives/api/[tableId]/route.ts

@@ -2,6 +2,7 @@ import { NextResponse } from 'next/server'
 import { z } from 'zod'
 import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
 import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
+import { withAtomicFlush } from '@open-mercato/shared/lib/commands/flush'
 import { perspectiveSaveSchema } from '@open-mercato/core/modules/perspectives/data/validators'
 import {
   loadPerspectivesState,
@@ -162,17 +163,12 @@ export async function POST(req: Request, ctx: { params: { tableId: string } }) {
   }
 
   const scope = buildScope(auth)
-  const saved = await saveUserPerspective(em, cache, {
-    scope,
-    tableId,
-    input: parsed.data,
-  })
 
   const applyToRoles = Array.from(new Set(parsed.data.applyToRoles ?? [])).filter((id) => id.trim().length > 0)
   const clearRoleIds = Array.from(new Set(parsed.data.clearRoleIds ?? [])).filter((id) => id.trim().length > 0)
-  let updatedRolePerspectives: Awaited<ReturnType<typeof saveRolePerspectives>> | null = null
+  const hasRoleOps = applyToRoles.length > 0 || clearRoleIds.length > 0
 
-  if (applyToRoles.length > 0 || clearRoleIds.length > 0) {
+  if (hasRoleOps) {
     const canApplyToRoles = await rbac.userHasAllFeatures?.(
       auth.sub,
       ['perspectives.role_defaults'],
@@ -198,30 +194,45 @@ export async function POST(req: Request, ctx: { params: { tableId: string } }) {
     if (missing.length) {
       return NextResponse.json({ error: 'Invalid roles', missing }, { status: 400 })
     }
+  }
 
-    if (applyToRoles.length) {
-      updatedRolePerspectives = await saveRolePerspectives(em, cache, {
-        tableId,
-        tenantId: auth.tenantId ?? null,
-        organizationId: auth.orgId ?? null,
-        input: {
-          roleIds: applyToRoles,
-          name: parsed.data.name,
-          settings: parsed.data.settings,
-          setDefault: parsed.data.setRoleDefault ?? false,
-        },
-      })
-    }
+  let saved: Awaited<ReturnType<typeof saveUserPerspective>> | null = null
+  let updatedRolePerspectives: Awaited<ReturnType<typeof saveRolePerspectives>> | null = null
 
-    if (clearRoleIds.length) {
-      await clearRolePerspectives(em, cache, {
+  await withAtomicFlush(em, [
+    async () => {
+      saved = await saveUserPerspective(em, cache, {
+        scope,
         tableId,
-        tenantId: auth.tenantId ?? null,
-        organizationId: auth.orgId ?? null,
-        roleIds: clearRoleIds,
+        input: parsed.data,
       })
-    }
-  }
+    },
+    async () => {
+      if (applyToRoles.length) {
+        updatedRolePerspectives = await saveRolePerspectives(em, cache, {
+          tableId,
+          tenantId: auth.tenantId ?? null,
+          organizationId: auth.orgId ?? null,
+          input: {
+            roleIds: applyToRoles,
+            name: parsed.data.name,
+            settings: parsed.data.settings,
+            setDefault: parsed.data.setRoleDefault ?? false,
+          },
+        })
+      }
+    },
+    async () => {
+      if (clearRoleIds.length) {
+        await clearRolePerspectives(em, cache, {
+          tableId,
+          tenantId: auth.tenantId ?? null,
+          organizationId: auth.orgId ?? null,
+          roleIds: clearRoleIds,
+        })
+      }
+    },
+  ], { transaction: true })
 
   return NextResponse.json({
     perspective: saved,