@open-mercato/core 0.6.6-develop.6255.1.a6ee4a57c1 → 0.6.6-develop.6257.1.6d0af84d26

package/src/modules/messages/components/message-detail/types.ts

@@ -97,6 +97,8 @@ export type MessageDetail = {
     objects?: MessageDetailObject[]
   }>
   isRead: boolean
+  conversationArchived?: boolean
+  conversationAllUnread?: boolean
 }
 
 export type ActionResult = {

package/src/modules/messages/i18n/de.json

@@ -9,6 +9,7 @@
   "messages.actions.edit": "Bearbeiten",
   "messages.actions.executing": "Wird ausgeführt...",
   "messages.actions.forwardAll": "Alle weiterleiten",
+  "messages.actions.markAllRead": "Alle als gelesen markieren",
   "messages.actions.markAllUnread": "Alle als ungelesen markieren",
   "messages.actions.markRead": "Als gelesen markieren",
   "messages.actions.markUnread": "Als ungelesen markieren",
@@ -16,6 +17,7 @@
   "messages.actions.taken": "Aktion ausgeführt",
   "messages.actions.title": "Aktionen",
   "messages.actions.unarchive": "Wiederherstellen",
+  "messages.actions.unarchiveConversation": "Konversation wiederherstellen",
   "messages.attachFiles": "Dateien anhängen",
   "messages.attachObject": "Objekt anhängen",
   "messages.attachedFiles": "Anhänge",
@@ -146,7 +148,9 @@
   "messages.flash.actionSuccess": "Aktion abgeschlossen.",
   "messages.flash.conversationArchived": "Konversation archiviert.",
   "messages.flash.conversationDeleted": "Konversation gelöscht.",
+  "messages.flash.conversationMarkedRead": "Konversation als gelesen markiert.",
   "messages.flash.conversationMarkedUnread": "Konversation als ungelesen markiert.",
+  "messages.flash.conversationUnarchived": "Konversation wiederhergestellt.",
   "messages.flash.deleted": "Nachricht gelöscht.",
   "messages.flash.draftSaved": "Entwurf gespeichert.",
   "messages.flash.forwardSuccess": "Nachricht weitergeleitet.",

package/src/modules/messages/i18n/en.json

@@ -9,6 +9,7 @@
   "messages.actions.edit": "Edit",
   "messages.actions.executing": "Executing...",
   "messages.actions.forwardAll": "Forward all",
+  "messages.actions.markAllRead": "Mark all read",
   "messages.actions.markAllUnread": "Mark all unread",
   "messages.actions.markRead": "Mark read",
   "messages.actions.markUnread": "Mark unread",
@@ -16,6 +17,7 @@
   "messages.actions.taken": "Action taken",
   "messages.actions.title": "Actions",
   "messages.actions.unarchive": "Unarchive",
+  "messages.actions.unarchiveConversation": "Unarchive conversation",
   "messages.attachFiles": "Attach files",
   "messages.attachObject": "Attach object",
   "messages.attachedFiles": "Attachments",
@@ -146,7 +148,9 @@
   "messages.flash.actionSuccess": "Action completed.",
   "messages.flash.conversationArchived": "Conversation archived.",
   "messages.flash.conversationDeleted": "Conversation deleted.",
+  "messages.flash.conversationMarkedRead": "Conversation marked read.",
   "messages.flash.conversationMarkedUnread": "Conversation marked unread.",
+  "messages.flash.conversationUnarchived": "Conversation restored from archive.",
   "messages.flash.deleted": "Message deleted.",
   "messages.flash.draftSaved": "Draft saved.",
   "messages.flash.forwardSuccess": "Message forwarded.",

package/src/modules/messages/i18n/es.json

@@ -9,6 +9,7 @@
   "messages.actions.edit": "Editar",
   "messages.actions.executing": "Ejecutando...",
   "messages.actions.forwardAll": "Reenviar todo",
+  "messages.actions.markAllRead": "Marcar todo como leído",
   "messages.actions.markAllUnread": "Marcar todo como no leído",
   "messages.actions.markRead": "Marcar como leído",
   "messages.actions.markUnread": "Marcar como no leído",
@@ -16,6 +17,7 @@
   "messages.actions.taken": "Acción realizada",
   "messages.actions.title": "Acciones",
   "messages.actions.unarchive": "Desarchivar",
+  "messages.actions.unarchiveConversation": "Desarchivar conversación",
   "messages.attachFiles": "Adjuntar archivos",
   "messages.attachObject": "Adjuntar objeto",
   "messages.attachedFiles": "Adjuntos",
@@ -146,7 +148,9 @@
   "messages.flash.actionSuccess": "Acción completada.",
   "messages.flash.conversationArchived": "Conversación archivada.",
   "messages.flash.conversationDeleted": "Conversación eliminada.",
+  "messages.flash.conversationMarkedRead": "Conversación marcada como leída.",
   "messages.flash.conversationMarkedUnread": "Conversación marcada como no leída.",
+  "messages.flash.conversationUnarchived": "Conversación desarchivada.",
   "messages.flash.deleted": "Mensaje eliminado.",
   "messages.flash.draftSaved": "Borrador guardado.",
   "messages.flash.forwardSuccess": "Mensaje reenviado.",

package/src/modules/messages/i18n/pl.json

@@ -9,6 +9,7 @@
   "messages.actions.edit": "Edytuj",
   "messages.actions.executing": "Wykonywanie...",
   "messages.actions.forwardAll": "Przekaż cały wątek",
+  "messages.actions.markAllRead": "Oznacz wszystko jako przeczytane",
   "messages.actions.markAllUnread": "Oznacz wszystko jako nieprzeczytane",
   "messages.actions.markRead": "Oznacz jako przeczytane",
   "messages.actions.markUnread": "Oznacz jako nieprzeczytane",
@@ -16,6 +17,7 @@
   "messages.actions.taken": "Wykonana akcja",
   "messages.actions.title": "Akcje",
   "messages.actions.unarchive": "Przywróć z archiwum",
+  "messages.actions.unarchiveConversation": "Przywróć konwersację z archiwum",
   "messages.attachFiles": "Dołącz pliki",
   "messages.attachObject": "Dołącz obiekt",
   "messages.attachedFiles": "Załączniki",
@@ -146,7 +148,9 @@
   "messages.flash.actionSuccess": "Akcja wykonana.",
   "messages.flash.conversationArchived": "Konwersacja zarchiwizowana.",
   "messages.flash.conversationDeleted": "Konwersacja usunięta.",
+  "messages.flash.conversationMarkedRead": "Konwersacja oznaczona jako przeczytana.",
   "messages.flash.conversationMarkedUnread": "Konwersacja oznaczona jako nieprzeczytana.",
+  "messages.flash.conversationUnarchived": "Konwersacja przywrócona z archiwum.",
   "messages.flash.deleted": "Wiadomość usunięta.",
   "messages.flash.draftSaved": "Szkic zapisany.",
   "messages.flash.forwardSuccess": "Wiadomość przekazana.",

package/src/modules/perspectives/api/[tableId]/[perspectiveId]/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 { isCrudHttpError } from '@open-mercato/shared/lib/crud/errors'
 import {
   runCrudMutationGuardAfterSuccess,
   validateCrudMutationGuard,
@@ -59,15 +60,24 @@ export async function DELETE(req: Request, ctx: { params: { tableId: string; per
     return NextResponse.json(guardResult.body, { status: guardResult.status })
   }
 
-  const deleted = await deleteUserPerspective(em, cache, {
-    scope: {
-      userId: auth.sub,
-      tenantId: auth.tenantId ?? null,
-      organizationId: auth.orgId ?? null,
-    },
-    tableId,
-    perspectiveId,
-  })
+  let deleted = false
+  try {
+    deleted = await deleteUserPerspective(em, cache, {
+      scope: {
+        userId: auth.sub,
+        tenantId: auth.tenantId ?? null,
+        organizationId: auth.orgId ?? null,
+      },
+      tableId,
+      perspectiveId,
+      request: req,
+    })
+  } catch (err) {
+    if (isCrudHttpError(err)) {
+      return NextResponse.json(err.body, { status: err.status })
+    }
+    throw err
+  }
 
   if (deleted && guardResult?.ok && guardResult.shouldRunAfterSuccess) {
     await runCrudMutationGuardAfterSuccess(container, {
@@ -101,6 +111,7 @@ const perspectiveDeleteDoc: OpenApiMethodDoc = {
   errors: [
     { status: 400, description: 'Invalid identifiers supplied', schema: perspectivesErrorSchema },
     { status: 401, description: 'Authentication required', schema: perspectivesErrorSchema },
+    { status: 409, description: 'Optimistic lock conflict', schema: perspectivesErrorSchema },
     { status: 404, description: 'Perspective not found', schema: perspectivesErrorSchema },
   ],
 }

package/src/modules/perspectives/api/[tableId]/roles/[roleId]/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 { isCrudHttpError } from '@open-mercato/shared/lib/crud/errors'
 import {
   runCrudMutationGuardAfterSuccess,
   validateCrudMutationGuard,
@@ -25,6 +26,11 @@ const decodeParam = (value: string | string[] | undefined): string => {
   }
 }
 
+const rolePerspectiveDeleteBodySchema = z.object({
+  roleExpectedUpdatedAtByRoleId: z.record(z.string().uuid(), z.string().min(1).nullable()).optional(),
+  roleExpectedUpdatedAtByPerspectiveId: z.record(z.string().uuid(), z.string().min(1).nullable()).optional(),
+}).optional()
+
 export async function DELETE(req: Request, ctx: { params: { tableId: string; roleId: string } }) {
   const auth = await getAuthFromRequest(req)
   if (!auth) return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
@@ -35,6 +41,22 @@ export async function DELETE(req: Request, ctx: { params: { tableId: string; rol
     return NextResponse.json({ error: 'Invalid parameters' }, { status: 400 })
   }
 
+  let parsedBody: z.infer<typeof rolePerspectiveDeleteBodySchema> = undefined
+  if (req.body && (req.headers.get('content-type') ?? '').includes('application/json')) {
+    try {
+      const rawBody = await req.text()
+      if (rawBody.trim().length > 0) {
+        const parsed = rolePerspectiveDeleteBodySchema.safeParse(JSON.parse(rawBody))
+        if (!parsed.success) {
+          return NextResponse.json({ error: 'Invalid payload', details: parsed.error.flatten() }, { status: 400 })
+        }
+        parsedBody = parsed.data
+      }
+    } catch {
+      return NextResponse.json({ error: 'Invalid JSON' }, { status: 400 })
+    }
+  }
+
   const container = await createRequestContainer()
   const em = container.resolve('em') as import('@mikro-orm/postgresql').EntityManager
   const cache = ((): import('@open-mercato/cache').CacheStrategy | null => {
@@ -67,12 +89,23 @@ export async function DELETE(req: Request, ctx: { params: { tableId: string; rol
     return NextResponse.json(guardResult.body, { status: guardResult.status })
   }
 
-  const clearedCount = await clearRolePerspectives(em, cache, {
-    tableId,
-    tenantId: auth.tenantId ?? null,
-    organizationId: auth.orgId ?? null,
-    roleIds: [roleId],
-  })
+  let clearedCount = 0
+  try {
+    clearedCount = await clearRolePerspectives(em, cache, {
+      tableId,
+      tenantId: auth.tenantId ?? null,
+      organizationId: auth.orgId ?? null,
+      roleIds: [roleId],
+      expectedUpdatedAtByRoleId: parsedBody?.roleExpectedUpdatedAtByRoleId,
+      expectedUpdatedAtByPerspectiveId: parsedBody?.roleExpectedUpdatedAtByPerspectiveId,
+      request: req,
+    })
+  } catch (err) {
+    if (isCrudHttpError(err)) {
+      return NextResponse.json(err.body, { status: err.status })
+    }
+    throw err
+  }
 
   if (clearedCount > 0 && guardResult?.ok && guardResult.shouldRunAfterSuccess) {
     await runCrudMutationGuardAfterSuccess(container, {
@@ -100,6 +133,11 @@ const rolePerspectiveDeleteDoc: OpenApiMethodDoc = {
   summary: 'Clear role perspectives for a table',
   description: 'Removes all role-level perspectives associated with the provided role identifier for the table.',
   tags: [perspectivesTag],
+  requestBody: {
+    contentType: 'application/json',
+    schema: rolePerspectiveDeleteBodySchema,
+    description: 'Optional per-role or per-perspective optimistic-lock tokens.',
+  },
   responses: [
     { status: 200, description: 'Role perspectives cleared.', schema: perspectivesSuccessSchema },
   ],
@@ -107,6 +145,7 @@ const rolePerspectiveDeleteDoc: OpenApiMethodDoc = {
     { status: 400, description: 'Invalid identifiers supplied', schema: perspectivesErrorSchema },
     { status: 401, description: 'Authentication required', schema: perspectivesErrorSchema },
     { status: 403, description: 'Missing perspectives.role_defaults feature', schema: perspectivesErrorSchema },
+    { status: 409, description: 'Optimistic lock conflict', schema: perspectivesErrorSchema },
     { status: 404, description: 'Role not found in scope', schema: perspectivesErrorSchema },
   ],
 }

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

@@ -96,15 +96,26 @@ export async function GET(_req: Request, ctx: { params: { tableId: string } }) {
   const availableRoles = canApplyToRoles
     ? await em.find(Role, { ...roleScope as any, deletedAt: null } as any, { orderBy: { name: 'asc' } })
     : assignedRoles
+  const manageableRoleIds = canApplyToRoles
+    ? availableRoles.map((role) => role.id)
+    : assignedRoleIds
 
   const state = await loadPerspectivesState(em, cache, {
     scope: buildScope(auth),
     tableId,
     roleIds: assignedRoleIds,
   })
+  const manageableState = manageableRoleIds.length === assignedRoleIds.length
+    && manageableRoleIds.every((roleId) => assignedRoleIds.includes(roleId))
+    ? state
+    : await loadPerspectivesState(em, cache, {
+      scope: buildScope(auth),
+      tableId,
+      roleIds: manageableRoleIds,
+    })
 
   const rolePerspectiveByRole = new Map<string, { hasDefault: boolean; count: number }>()
-  for (const item of state.rolePerspectives) {
+  for (const item of manageableState.rolePerspectives) {
     const entry = rolePerspectiveByRole.get(item.roleId) ?? { hasDefault: false, count: 0 }
     entry.count += 1
     entry.hasDefault = entry.hasDefault || item.isDefault
@@ -119,6 +130,10 @@ export async function GET(_req: Request, ctx: { params: { tableId: string } }) {
       ...rp,
       roleName: availableRoles.find((role) => role.id === rp.roleId)?.name ?? assignedRoles.find((role) => role.id === rp.roleId)?.name ?? null,
     })),
+    manageableRolePerspectives: manageableState.rolePerspectives.map((rp) => ({
+      ...rp,
+      roleName: availableRoles.find((role) => role.id === rp.roleId)?.name ?? assignedRoles.find((role) => role.id === rp.roleId)?.name ?? null,
+    })),
     roles: availableRoles.map((role) => {
       const stats = rolePerspectiveByRole.get(role.id)
       return {
@@ -269,6 +284,9 @@ export async function POST(req: Request, ctx: { params: { tableId: string } }) {
               settings: parsed.data.settings,
               setDefault: parsed.data.setRoleDefault ?? false,
             },
+            expectedUpdatedAtByRoleId: parsed.data.roleExpectedUpdatedAtByRoleId,
+            expectedUpdatedAtByPerspectiveId: parsed.data.roleExpectedUpdatedAtByPerspectiveId,
+            request: req,
           })
         }
       },
@@ -279,6 +297,9 @@ export async function POST(req: Request, ctx: { params: { tableId: string } }) {
             tenantId: auth.tenantId ?? null,
             organizationId: auth.orgId ?? null,
             roleIds: clearRoleIds,
+            expectedUpdatedAtByRoleId: parsed.data.roleExpectedUpdatedAtByRoleId,
+            expectedUpdatedAtByPerspectiveId: parsed.data.roleExpectedUpdatedAtByPerspectiveId,
+            request: req,
           })
         }
       },
@@ -359,6 +380,7 @@ const perspectivesPostDoc: OpenApiMethodDoc = {
     { status: 400, description: 'Validation failed or invalid roles provided', schema: perspectivesErrorSchema },
     { status: 401, description: 'Authentication required', schema: perspectivesErrorSchema },
     { status: 403, description: 'Missing perspectives.role_defaults feature for role updates', schema: perspectivesErrorSchema },
+    { status: 409, description: 'Optimistic lock conflict', schema: perspectivesErrorSchema },
   ],
 }
 

package/src/modules/perspectives/api/openapi.ts

@@ -29,6 +29,7 @@ export const perspectivesIndexResponseSchema = z.object({
   perspectives: z.array(perspectiveDtoSchema),
   defaultPerspectiveId: z.string().uuid().nullable(),
   rolePerspectives: z.array(rolePerspectiveDtoSchema),
+  manageableRolePerspectives: z.array(rolePerspectiveDtoSchema),
   roles: z.array(
     z.object({
       id: z.string().uuid(),
@@ -49,4 +50,3 @@ export const perspectiveSaveResponseSchema = z.object({
 export const perspectivesSuccessSchema = z.object({
   success: z.literal(true),
 })
-

package/src/modules/perspectives/data/validators.ts

@@ -22,6 +22,8 @@ export const perspectiveSaveSchema = z.object({
   isDefault: z.boolean().optional(),
   applyToRoles: z.array(z.string().uuid()).optional(),
   clearRoleIds: z.array(z.string().uuid()).optional(),
+  roleExpectedUpdatedAtByRoleId: z.record(z.string().uuid(), z.string().min(1).nullable()).optional(),
+  roleExpectedUpdatedAtByPerspectiveId: z.record(z.string().uuid(), z.string().min(1).nullable()).optional(),
   setRoleDefault: z.boolean().optional(),
 })
 

package/src/modules/perspectives/services/perspectiveService.ts

@@ -1,6 +1,11 @@
 import type { EntityManager } from '@mikro-orm/postgresql'
 import type { CacheStrategy } from '@open-mercato/cache'
-import { enforceCommandOptimisticLock } from '@open-mercato/shared/lib/crud/optimistic-lock-command'
+import { CrudHttpError } from '@open-mercato/shared/lib/crud/errors'
+import {
+  buildOptimisticLockConflictBody,
+  enforceCommandOptimisticLock,
+  enforceRecordGoneIsConflict,
+} from '@open-mercato/shared/lib/crud/optimistic-lock-command'
 import { Perspective, RolePerspective } from '../data/entities'
 import type {
   PerspectiveSettings,
@@ -44,6 +49,50 @@ export type PerspectivesState = {
   rolePerspectives: ResolvedRolePerspective[]
 }
 
+type ExpectedUpdatedAtById = Record<string, string | Date | null | undefined>
+
+const PERSPECTIVE_RESOURCE_KIND = 'perspectives.perspective'
+const ROLE_PERSPECTIVE_RESOURCE_KIND = 'perspectives.role_perspective'
+
+function resolveRoleLockInput(
+  expectedUpdatedAtByRoleId: ExpectedUpdatedAtById | null | undefined,
+  roleId: string,
+  request: Request | Headers | null | undefined,
+): Pick<Parameters<typeof enforceCommandOptimisticLock>[0], 'expected' | 'request'> {
+  if (expectedUpdatedAtByRoleId && Object.prototype.hasOwnProperty.call(expectedUpdatedAtByRoleId, roleId)) {
+    return { expected: expectedUpdatedAtByRoleId[roleId] ?? null, request: null }
+  }
+  return { expected: undefined, request: request ?? null }
+}
+
+function resolveRoleRecordLockInput(
+  expectedUpdatedAtByPerspectiveId: ExpectedUpdatedAtById | null | undefined,
+  expectedUpdatedAtByRoleId: ExpectedUpdatedAtById | null | undefined,
+  record: RolePerspective,
+  request: Request | Headers | null | undefined,
+): Pick<Parameters<typeof enforceCommandOptimisticLock>[0], 'expected' | 'request'> {
+  if (expectedUpdatedAtByPerspectiveId && Object.prototype.hasOwnProperty.call(expectedUpdatedAtByPerspectiveId, record.id)) {
+    return { expected: expectedUpdatedAtByPerspectiveId[record.id] ?? null, request: null }
+  }
+  return resolveRoleLockInput(expectedUpdatedAtByRoleId, record.roleId, request)
+}
+
+function firstExpectedUpdatedAt(expectedUpdatedAtById: ExpectedUpdatedAtById | null | undefined): string | Date | null {
+  if (!expectedUpdatedAtById) return null
+  for (const value of Object.values(expectedUpdatedAtById)) {
+    if (value instanceof Date) return value
+    if (typeof value === 'string' && value.trim().length > 0) return value
+  }
+  return null
+}
+
+function throwMissingRoleRecordVersionConflict(record: RolePerspective): never {
+  const current = record.updatedAt instanceof Date && Number.isFinite(record.updatedAt.getTime())
+    ? record.updatedAt.toISOString()
+    : new Date(0).toISOString()
+  throw new CrudHttpError(409, buildOptimisticLockConflictBody(current, current))
+}
+
 const CACHE_TTL_MS = 5 * 60 * 1000
 
 const nullish = <T extends string | null | undefined>(value: T): string | null =>
@@ -242,7 +291,7 @@ export async function saveUserPerspective(
       throw Object.assign(new Error('Perspective not found'), { code: 'NOT_FOUND' })
     }
     enforceCommandOptimisticLock({
-      resourceKind: 'perspectives.perspective',
+      resourceKind: PERSPECTIVE_RESOURCE_KIND,
       resourceId: entity.id,
       current: entity.updatedAt ?? null,
       request: options.request ?? null,
@@ -308,7 +357,12 @@ export async function saveUserPerspective(
 export async function deleteUserPerspective(
   em: EntityManager,
   cache: CacheStrategy | null | undefined,
-  options: { scope: PerspectiveScope; tableId: string; perspectiveId: string },
+  options: {
+    scope: PerspectiveScope
+    tableId: string
+    perspectiveId: string
+    request?: Request | Headers | null
+  },
 ): Promise<boolean> {
   const { scope, tableId, perspectiveId } = options
   const tenantId = scope.tenantId ?? null
@@ -322,7 +376,21 @@ export async function deleteUserPerspective(
     tableId,
     deletedAt: null,
   })
-  if (!existing) return false
+  if (!existing) {
+    enforceRecordGoneIsConflict({
+      resourceKind: PERSPECTIVE_RESOURCE_KIND,
+      resourceId: perspectiveId,
+      request: options.request ?? null,
+    })
+    return false
+  }
+
+  enforceCommandOptimisticLock({
+    resourceKind: PERSPECTIVE_RESOURCE_KIND,
+    resourceId: existing.id,
+    current: existing.updatedAt ?? null,
+    request: options.request ?? null,
+  })
 
   existing.deletedAt = new Date()
   existing.isDefault = false
@@ -343,6 +411,9 @@ export async function saveRolePerspectives(
     tenantId?: string | null
     organizationId?: string | null
     input: RolePerspectiveSaveInput
+    expectedUpdatedAtByRoleId?: ExpectedUpdatedAtById
+    expectedUpdatedAtByPerspectiveId?: ExpectedUpdatedAtById
+    request?: Request | Headers | null
   },
 ): Promise<ResolvedRolePerspective[]> {
   const { tableId, input } = options
@@ -351,7 +422,7 @@ export async function saveRolePerspectives(
   const now = new Date()
   const touchedRoleIds = new Set<string>()
 
-  const results: ResolvedRolePerspective[] = []
+  const resultRecords: RolePerspective[] = []
 
   // Prefetch every matching role perspective in a single query, then index by role id
   // so the loop resolves create/update without a lookup per role.
@@ -367,6 +438,22 @@ export async function saveRolePerspectives(
     })
     for (const existing of existingRecords) recordByRole.set(existing.roleId, existing)
   }
+  const defaultRecordsByRole = new Map<string, RolePerspective[]>()
+  if (input.setDefault === true && input.roleIds.length) {
+    const existingDefaultRecords = await em.find(RolePerspective, {
+      roleId: { $in: input.roleIds },
+      tableId,
+      tenantId,
+      organizationId,
+      isDefault: true,
+      deletedAt: null,
+    })
+    for (const existing of existingDefaultRecords) {
+      const records = defaultRecordsByRole.get(existing.roleId) ?? []
+      records.push(existing)
+      defaultRecordsByRole.set(existing.roleId, records)
+    }
+  }
 
   for (const roleId of input.roleIds) {
     let record = recordByRole.get(roleId) ?? null
@@ -385,6 +472,17 @@ export async function saveRolePerspectives(
       em.persist(record)
       recordByRole.set(roleId, record)
     } else {
+      enforceCommandOptimisticLock({
+        resourceKind: ROLE_PERSPECTIVE_RESOURCE_KIND,
+        resourceId: record.id,
+        current: record.updatedAt ?? null,
+        ...resolveRoleRecordLockInput(
+          options.expectedUpdatedAtByPerspectiveId,
+          options.expectedUpdatedAtByRoleId,
+          record,
+          options.request ?? null,
+        ),
+      })
       record.settingsJson = input.settings
       record.updatedAt = now
       if (input.setDefault === true) record.isDefault = true
@@ -392,6 +490,20 @@ export async function saveRolePerspectives(
     }
 
     if (input.setDefault === true) {
+      for (const defaultRecord of defaultRecordsByRole.get(roleId) ?? []) {
+        if (defaultRecord.id === record.id) continue
+        enforceCommandOptimisticLock({
+          resourceKind: ROLE_PERSPECTIVE_RESOURCE_KIND,
+          resourceId: defaultRecord.id,
+          current: defaultRecord.updatedAt ?? null,
+          ...resolveRoleRecordLockInput(
+            options.expectedUpdatedAtByPerspectiveId,
+            options.expectedUpdatedAtByRoleId,
+            defaultRecord,
+            options.request ?? null,
+          ),
+        })
+      }
       await em.nativeUpdate(
         RolePerspective,
         {
@@ -400,6 +512,7 @@ export async function saveRolePerspectives(
           tenantId,
           organizationId,
           id: { $ne: record.id } as any,
+          isDefault: true,
           deletedAt: null,
         },
         { isDefault: false, updatedAt: now },
@@ -408,7 +521,7 @@ export async function saveRolePerspectives(
     }
 
     touchedRoleIds.add(roleId)
-    results.push(toResolvedRolePerspective(record))
+    resultRecords.push(record)
   }
 
   if (input.roleIds.length) {
@@ -420,7 +533,7 @@ export async function saveRolePerspectives(
     await cache.deleteByTags(tags)
   }
 
-  return results
+  return resultRecords.map(toResolvedRolePerspective)
 }
 
 export async function clearRolePerspectives(
@@ -431,6 +544,9 @@ export async function clearRolePerspectives(
     tenantId?: string | null
     organizationId?: string | null
     roleIds: string[]
+    expectedUpdatedAtByRoleId?: ExpectedUpdatedAtById
+    expectedUpdatedAtByPerspectiveId?: ExpectedUpdatedAtById
+    request?: Request | Headers | null
   },
 ): Promise<number> {
   const { tableId, roleIds } = options
@@ -438,6 +554,54 @@ export async function clearRolePerspectives(
   const organizationId = options.organizationId ?? null
   if (!roleIds.length) return 0
 
+  const existingRecords = await em.find(RolePerspective, {
+    roleId: { $in: roleIds as any },
+    tableId,
+    tenantId,
+    organizationId,
+    deletedAt: null,
+  })
+  const recordsByRole = new Map<string, RolePerspective[]>()
+  for (const record of existingRecords) {
+    const records = recordsByRole.get(record.roleId) ?? []
+    records.push(record)
+    recordsByRole.set(record.roleId, records)
+  }
+
+  for (const roleId of roleIds) {
+    const records = recordsByRole.get(roleId) ?? []
+    const lockInput = resolveRoleLockInput(options.expectedUpdatedAtByRoleId, roleId, options.request ?? null)
+    if (!records.length) {
+      const expected = firstExpectedUpdatedAt(options.expectedUpdatedAtByPerspectiveId)
+      enforceRecordGoneIsConflict({
+        resourceKind: ROLE_PERSPECTIVE_RESOURCE_KIND,
+        resourceId: roleId,
+        expected: expected ?? lockInput.expected,
+        request: expected ? null : lockInput.request,
+      })
+      continue
+    }
+    for (const record of records) {
+      if (
+        options.expectedUpdatedAtByPerspectiveId
+        && !Object.prototype.hasOwnProperty.call(options.expectedUpdatedAtByPerspectiveId, record.id)
+      ) {
+        throwMissingRoleRecordVersionConflict(record)
+      }
+      enforceCommandOptimisticLock({
+        resourceKind: ROLE_PERSPECTIVE_RESOURCE_KIND,
+        resourceId: record.id,
+        current: record.updatedAt ?? null,
+        ...resolveRoleRecordLockInput(
+          options.expectedUpdatedAtByPerspectiveId,
+          options.expectedUpdatedAtByRoleId,
+          record,
+          options.request ?? null,
+        ),
+      })
+    }
+  }
+
   const affected = await em.nativeUpdate(
     RolePerspective,
     {