@open-mercato/core 0.6.6-develop.6253.1.a8c2b49d90 → 0.6.6-develop.6256.1.9fc16aedc4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-mercato/core",
-  "version": "0.6.6-develop.6253.1.a8c2b49d90",
+  "version": "0.6.6-develop.6256.1.9fc16aedc4",
   "license": "MIT",
   "type": "module",
   "main": "./dist/index.js",
@@ -246,16 +246,16 @@
     "zod": "^4.4.3"
   },
   "peerDependencies": {
-    "@open-mercato/ai-assistant": "0.6.6-develop.6253.1.a8c2b49d90",
-    "@open-mercato/shared": "0.6.6-develop.6253.1.a8c2b49d90",
-    "@open-mercato/ui": "0.6.6-develop.6253.1.a8c2b49d90",
+    "@open-mercato/ai-assistant": "0.6.6-develop.6256.1.9fc16aedc4",
+    "@open-mercato/shared": "0.6.6-develop.6256.1.9fc16aedc4",
+    "@open-mercato/ui": "0.6.6-develop.6256.1.9fc16aedc4",
     "react": "^19.0.0",
     "react-dom": "^19.0.0"
   },
   "devDependencies": {
-    "@open-mercato/ai-assistant": "0.6.6-develop.6253.1.a8c2b49d90",
-    "@open-mercato/shared": "0.6.6-develop.6253.1.a8c2b49d90",
-    "@open-mercato/ui": "0.6.6-develop.6253.1.a8c2b49d90",
+    "@open-mercato/ai-assistant": "0.6.6-develop.6256.1.9fc16aedc4",
+    "@open-mercato/shared": "0.6.6-develop.6256.1.9fc16aedc4",
+    "@open-mercato/ui": "0.6.6-develop.6256.1.9fc16aedc4",
     "@testing-library/dom": "^10.4.1",
     "@testing-library/jest-dom": "^6.9.1",
     "@testing-library/react": "^16.3.1",

package/src/modules/customers/components/calendar/TimeGrid.tsx

@@ -172,6 +172,7 @@ export function TimeGrid({
   const scrollRef = React.useRef<HTMLDivElement | null>(null)
   const nowMs = Date.now()
   const today = startOfDay(new Date())
+  const todayMs = today.getTime()
   const anchorMs = anchor.getTime()
   const [selectedId, setSelectedId] = React.useState<string | null>(null)
   const [drag, setDrag] = React.useState<DragState | null>(null)
@@ -179,8 +180,8 @@ export function TimeGrid({
   const dayStarts = React.useMemo(() => {
     const rangeStart = getVisibleRange(days === 7 ? 'week' : 'day', new Date(anchorMs), 0).from
     const all = Array.from({ length: days }, (_, index) => addDays(rangeStart, index))
-    return days === 7 ? applyWeekendVisibility(all, showWeekends) : all
-  }, [days, anchorMs, showWeekends])
+    return days === 7 ? applyWeekendVisibility(all, showWeekends, new Date(todayMs)) : all
+  }, [days, anchorMs, showWeekends, todayMs])
 
   const dayColumns = React.useMemo(
     () => dayStarts.map((dayStart) => buildDayColumn(dayStart, items)),

package/src/modules/customers/lib/calendar/grid.ts

@@ -1,3 +1,5 @@
+import { isSameDay } from 'date-fns/isSameDay'
+
 export const DRAG_SNAP_MINUTES = 15
 export const MIN_DRAG_DURATION_MINUTES = 30
 const MINUTES_PER_DAY = 24 * 60
@@ -7,9 +9,15 @@ export function isWeekendDay(date: Date): boolean {
   return weekday === 0 || weekday === 6
 }
 
-export function applyWeekendVisibility(days: Date[], showWeekends: boolean): Date[] {
+export function applyWeekendVisibility(
+  days: Date[],
+  showWeekends: boolean,
+  keepWeekendDate?: Date | null,
+): Date[] {
   if (showWeekends) return days
-  const workingDays = days.filter((day) => !isWeekendDay(day))
+  const workingDays = days.filter(
+    (day) => !isWeekendDay(day) || (keepWeekendDate != null && isSameDay(day, keepWeekendDate)),
+  )
   return workingDays.length > 0 ? workingDays : days
 }
 

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,
     {

package/src/modules/query_index/lib/engine.ts

@@ -935,7 +935,11 @@ export class HybridQueryEngine implements QueryEngine {
         const cap = resolveEncryptedSortMaxRows()
         const phase1Root = db.selectFrom(`${baseTable} as b` as any)
         let phase1 = await applyQueryShape(phase1Root)
-        const sortFieldNames = Array.from(new Set(['id', ...resolvedSorts.map((s) => String(s.field))]))
+        const scopeFieldNames = [
+          hasTenantColumn ? 'tenant_id' : null,
+          hasOrganizationColumn ? 'organization_id' : null,
+        ].filter((field): field is string => field !== null)
+        const sortFieldNames = Array.from(new Set(['id', ...scopeFieldNames, ...resolvedSorts.map((s) => String(s.field))]))
         phase1 = applySelection(phase1, sortFieldNames)
         if (cap !== null) {
           phase1 = phase1.limit(cap).orderBy(qualify('id'), 'asc' as any)