@open-mercato/core 0.6.6-develop.6257.1.6d0af84d26 → 0.6.6-develop.6286.1.d985c5c374

package/src/modules/payment_gateways/lib/gateway-service.ts

@@ -14,10 +14,34 @@ import {
 import type { CredentialsService } from '../../integrations/lib/credentials-service'
 import type { IntegrationStateService } from '../../integrations/lib/state-service'
 import type { IntegrationLogService } from '../../integrations/lib/log-service'
+import { conflict } from '@open-mercato/shared/lib/crud/errors'
 import { GatewayTransaction } from '../data/entities'
-import { isValidTransition } from './status-machine'
+import { canApplyManualAction, isValidTransition, type ManualGatewayAction } from './status-machine'
 import { emitPaymentGatewayEvent } from '../events'
 
+function assertManualActionAllowed(action: ManualGatewayAction, transaction: GatewayTransaction): void {
+  const current = transaction.unifiedStatus as UnifiedPaymentStatus
+  if (!canApplyManualAction(action, current)) {
+    throw conflict(`Cannot ${action} a payment in status "${current}"`)
+  }
+}
+
+function applyAdapterResultStatus(
+  action: ManualGatewayAction,
+  transaction: GatewayTransaction,
+  resultStatus: UnifiedPaymentStatus,
+): boolean {
+  const current = transaction.unifiedStatus as UnifiedPaymentStatus
+  if (resultStatus === current) return false
+  if (!isValidTransition(current, resultStatus)) {
+    throw conflict(
+      `Gateway returned status "${resultStatus}" which is not a valid transition from "${current}" for ${action}`,
+    )
+  }
+  transaction.unifiedStatus = resultStatus
+  return true
+}
+
 export interface PaymentGatewayServiceDeps {
   em: EntityManager
   integrationCredentialsService: CredentialsService
@@ -197,6 +221,7 @@ export function createPaymentGatewayService(deps: PaymentGatewayServiceDeps) {
 
     async capturePayment(transactionId: string, amount: number | undefined, scope: { organizationId: string; tenantId: string }): Promise<CaptureResult> {
       const transaction = await findTransactionOrThrow(transactionId, scope)
+      assertManualActionAllowed('capture', transaction)
       const { adapter, credentials } = await resolveAdapterAndCredentials(
         transaction.providerKey,
         { organizationId: transaction.organizationId, tenantId: transaction.tenantId },
@@ -208,16 +233,18 @@ export function createPaymentGatewayService(deps: PaymentGatewayServiceDeps) {
         credentials,
       })
 
-      transaction.unifiedStatus = result.status
+      const statusChanged = applyAdapterResultStatus('capture', transaction, result.status)
       transaction.gatewayMetadata = { ...transaction.gatewayMetadata, captureResult: result.providerData }
       await em.flush()
-      await emitStatusEvent(result.status, {
-        transactionId: transaction.id,
-        paymentId: transaction.paymentId,
-        providerKey: transaction.providerKey,
-        organizationId: transaction.organizationId,
-        tenantId: transaction.tenantId,
-      })
+      if (statusChanged) {
+        await emitStatusEvent(result.status, {
+          transactionId: transaction.id,
+          paymentId: transaction.paymentId,
+          providerKey: transaction.providerKey,
+          organizationId: transaction.organizationId,
+          tenantId: transaction.tenantId,
+        })
+      }
       await writeTransactionLog(
         transaction.providerKey,
         { organizationId: transaction.organizationId, tenantId: transaction.tenantId },
@@ -241,6 +268,7 @@ export function createPaymentGatewayService(deps: PaymentGatewayServiceDeps) {
       scope: { organizationId: string; tenantId: string },
     ): Promise<RefundResult> {
       const transaction = await findTransactionOrThrow(transactionId, scope)
+      assertManualActionAllowed('refund', transaction)
       const { adapter, credentials } = await resolveAdapterAndCredentials(
         transaction.providerKey,
         { organizationId: transaction.organizationId, tenantId: transaction.tenantId },
@@ -253,17 +281,19 @@ export function createPaymentGatewayService(deps: PaymentGatewayServiceDeps) {
         credentials,
       })
 
-      transaction.unifiedStatus = result.status
+      const statusChanged = applyAdapterResultStatus('refund', transaction, result.status)
       transaction.gatewayRefundId = result.refundId
       transaction.gatewayMetadata = { ...transaction.gatewayMetadata, refundResult: result.providerData }
       await em.flush()
-      await emitStatusEvent(result.status, {
-        transactionId: transaction.id,
-        paymentId: transaction.paymentId,
-        providerKey: transaction.providerKey,
-        organizationId: transaction.organizationId,
-        tenantId: transaction.tenantId,
-      })
+      if (statusChanged) {
+        await emitStatusEvent(result.status, {
+          transactionId: transaction.id,
+          paymentId: transaction.paymentId,
+          providerKey: transaction.providerKey,
+          organizationId: transaction.organizationId,
+          tenantId: transaction.tenantId,
+        })
+      }
       await writeTransactionLog(
         transaction.providerKey,
         { organizationId: transaction.organizationId, tenantId: transaction.tenantId },
@@ -287,6 +317,7 @@ export function createPaymentGatewayService(deps: PaymentGatewayServiceDeps) {
       scope: { organizationId: string; tenantId: string },
     ): Promise<CancelResult> {
       const transaction = await findTransactionOrThrow(transactionId, scope)
+      assertManualActionAllowed('cancel', transaction)
       const { adapter, credentials } = await resolveAdapterAndCredentials(
         transaction.providerKey,
         { organizationId: transaction.organizationId, tenantId: transaction.tenantId },
@@ -298,15 +329,17 @@ export function createPaymentGatewayService(deps: PaymentGatewayServiceDeps) {
         credentials,
       })
 
-      transaction.unifiedStatus = result.status
+      const statusChanged = applyAdapterResultStatus('cancel', transaction, result.status)
       await em.flush()
-      await emitStatusEvent(result.status, {
-        transactionId: transaction.id,
-        paymentId: transaction.paymentId,
-        providerKey: transaction.providerKey,
-        organizationId: transaction.organizationId,
-        tenantId: transaction.tenantId,
-      })
+      if (statusChanged) {
+        await emitStatusEvent(result.status, {
+          transactionId: transaction.id,
+          paymentId: transaction.paymentId,
+          providerKey: transaction.providerKey,
+          organizationId: transaction.organizationId,
+          tenantId: transaction.tenantId,
+        })
+      }
       await writeTransactionLog(
         transaction.providerKey,
         { organizationId: transaction.organizationId, tenantId: transaction.tenantId },

package/src/modules/payment_gateways/lib/status-machine.ts

@@ -26,3 +26,19 @@ export function isValidTransition(from: UnifiedPaymentStatus, to: UnifiedPayment
 export function isTerminalStatus(status: UnifiedPaymentStatus): boolean {
   return TERMINAL_STATUSES.has(status)
 }
+
+export type ManualGatewayAction = 'capture' | 'refund' | 'cancel'
+
+const MANUAL_ACTION_TARGET_STATUSES: Record<ManualGatewayAction, UnifiedPaymentStatus[]> = {
+  capture: ['captured', 'partially_captured'],
+  refund: ['refunded', 'partially_refunded'],
+  cancel: ['cancelled'],
+}
+
+export function canApplyManualAction(action: ManualGatewayAction, from: UnifiedPaymentStatus): boolean {
+  if (isTerminalStatus(from)) return false
+  const targets = MANUAL_ACTION_TARGET_STATUSES[action]
+  if (!targets) return false
+  if (targets.includes(from)) return true
+  return targets.some((target) => isValidTransition(from, target))
+}

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

@@ -3,7 +3,7 @@ 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 { isCrudHttpError } from '@open-mercato/shared/lib/crud/errors'
+import { isCrudHttpError, isUniqueViolation } from '@open-mercato/shared/lib/crud/errors'
 import {
   runCrudMutationGuardAfterSuccess,
   validateCrudMutationGuard,
@@ -308,6 +308,12 @@ export async function POST(req: Request, ctx: { params: { tableId: string } }) {
     if (isCrudHttpError(err)) {
       return NextResponse.json(err.body, { status: err.status })
     }
+    if (isUniqueViolation(err)) {
+      return NextResponse.json({
+        error: 'A view with this name already exists.',
+        code: 'duplicate_name',
+      }, { status: 409 })
+    }
     throw err
   }
 
@@ -380,7 +386,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 },
+    { status: 409, description: 'Optimistic lock conflict or perspective name already exists', schema: perspectivesErrorSchema },
   ],
 }
 

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

@@ -1,8 +1,28 @@
-import { Entity, Index, PrimaryKey, Property, Unique } from '@mikro-orm/decorators/legacy'
+import { Entity, Index, PrimaryKey, Property } from '@mikro-orm/decorators/legacy'
 
 @Entity({ tableName: 'perspectives' })
 @Index({ name: 'perspectives_user_scope_idx', properties: ['userId', 'tenantId', 'organizationId', 'tableId'] })
-@Unique({ properties: ['userId', 'tenantId', 'organizationId', 'tableId', 'name'] })
+// Live-row uniqueness is owned by partial indexes; ordinary unique decorators cannot express these scope rules.
+@Index({
+  name: 'perspectives_live_user_org_uq',
+  expression:
+    'create unique index "perspectives_live_user_org_uq" on "perspectives" ("user_id", "tenant_id", "organization_id", "table_id", "name") where "deleted_at" is null and "tenant_id" is not null and "organization_id" is not null',
+})
+@Index({
+  name: 'perspectives_live_user_tenant_uq',
+  expression:
+    'create unique index "perspectives_live_user_tenant_uq" on "perspectives" ("user_id", "tenant_id", "table_id", "name") where "deleted_at" is null and "tenant_id" is not null and "organization_id" is null',
+})
+@Index({
+  name: 'perspectives_live_user_org_only_uq',
+  expression:
+    'create unique index "perspectives_live_user_org_only_uq" on "perspectives" ("user_id", "organization_id", "table_id", "name") where "deleted_at" is null and "tenant_id" is null and "organization_id" is not null',
+})
+@Index({
+  name: 'perspectives_live_user_global_uq',
+  expression:
+    'create unique index "perspectives_live_user_global_uq" on "perspectives" ("user_id", "table_id", "name") where "deleted_at" is null and "tenant_id" is null and "organization_id" is null',
+})
 export class Perspective {
   @PrimaryKey({ type: 'uuid', defaultRaw: 'gen_random_uuid()' })
   id!: string
@@ -40,7 +60,27 @@ export class Perspective {
 
 @Entity({ tableName: 'role_perspectives' })
 @Index({ name: 'role_perspectives_role_scope_idx', properties: ['roleId', 'tenantId', 'organizationId', 'tableId'] })
-@Unique({ properties: ['roleId', 'tenantId', 'organizationId', 'tableId', 'name'] })
+// Live-row uniqueness is owned by partial indexes; ordinary unique decorators cannot express these scope rules.
+@Index({
+  name: 'role_perspectives_live_role_org_uq',
+  expression:
+    'create unique index "role_perspectives_live_role_org_uq" on "role_perspectives" ("role_id", "tenant_id", "organization_id", "table_id", "name") where "deleted_at" is null and "tenant_id" is not null and "organization_id" is not null',
+})
+@Index({
+  name: 'role_perspectives_live_role_tenant_uq',
+  expression:
+    'create unique index "role_perspectives_live_role_tenant_uq" on "role_perspectives" ("role_id", "tenant_id", "table_id", "name") where "deleted_at" is null and "tenant_id" is not null and "organization_id" is null',
+})
+@Index({
+  name: 'role_perspectives_live_role_org_only_uq',
+  expression:
+    'create unique index "role_perspectives_live_role_org_only_uq" on "role_perspectives" ("role_id", "organization_id", "table_id", "name") where "deleted_at" is null and "tenant_id" is null and "organization_id" is not null',
+})
+@Index({
+  name: 'role_perspectives_live_role_global_uq',
+  expression:
+    'create unique index "role_perspectives_live_role_global_uq" on "role_perspectives" ("role_id", "table_id", "name") where "deleted_at" is null and "tenant_id" is null and "organization_id" is null',
+})
 export class RolePerspective {
   @PrimaryKey({ type: 'uuid', defaultRaw: 'gen_random_uuid()' })
   id!: string

package/src/modules/perspectives/migrations/.snapshot-open-mercato.json

@@ -175,7 +175,7 @@
           "autoincrement": false,
           "primary": false,
           "nullable": false,
-          "unique": true,
+          "unique": false,
           "length": null,
           "precision": null,
           "scale": null,
@@ -197,18 +197,40 @@
           "unique": true
         },
         {
-          "columnNames": [
-            "user_id",
-            "tenant_id",
-            "organization_id",
-            "table_id",
-            "name"
-          ],
-          "composite": true,
-          "constraint": true,
-          "keyName": "perspectives_user_id_tenant_id_organization_id_ta_0c702_unique",
+          "columnNames": [],
+          "composite": false,
+          "constraint": false,
+          "keyName": "perspectives_live_user_global_uq",
           "primary": false,
-          "unique": true
+          "unique": false,
+          "expression": "create unique index \"perspectives_live_user_global_uq\" on \"perspectives\" (\"user_id\", \"table_id\", \"name\") where \"deleted_at\" is null and \"tenant_id\" is null and \"organization_id\" is null"
+        },
+        {
+          "columnNames": [],
+          "composite": false,
+          "constraint": false,
+          "keyName": "perspectives_live_user_org_only_uq",
+          "primary": false,
+          "unique": false,
+          "expression": "create unique index \"perspectives_live_user_org_only_uq\" on \"perspectives\" (\"user_id\", \"organization_id\", \"table_id\", \"name\") where \"deleted_at\" is null and \"tenant_id\" is null and \"organization_id\" is not null"
+        },
+        {
+          "columnNames": [],
+          "composite": false,
+          "constraint": false,
+          "keyName": "perspectives_live_user_org_uq",
+          "primary": false,
+          "unique": false,
+          "expression": "create unique index \"perspectives_live_user_org_uq\" on \"perspectives\" (\"user_id\", \"tenant_id\", \"organization_id\", \"table_id\", \"name\") where \"deleted_at\" is null and \"tenant_id\" is not null and \"organization_id\" is not null"
+        },
+        {
+          "columnNames": [],
+          "composite": false,
+          "constraint": false,
+          "keyName": "perspectives_live_user_tenant_uq",
+          "primary": false,
+          "unique": false,
+          "expression": "create unique index \"perspectives_live_user_tenant_uq\" on \"perspectives\" (\"user_id\", \"tenant_id\", \"table_id\", \"name\") where \"deleted_at\" is null and \"tenant_id\" is not null and \"organization_id\" is null"
         },
         {
           "columnNames": [
@@ -335,7 +357,7 @@
           "autoincrement": false,
           "primary": false,
           "nullable": false,
-          "unique": true,
+          "unique": false,
           "length": null,
           "precision": null,
           "scale": null,
@@ -421,18 +443,40 @@
           "unique": true
         },
         {
-          "columnNames": [
-            "role_id",
-            "tenant_id",
-            "organization_id",
-            "table_id",
-            "name"
-          ],
-          "composite": true,
-          "constraint": true,
-          "keyName": "role_perspectives_role_id_tenant_id_organization__f0fc6_unique",
+          "columnNames": [],
+          "composite": false,
+          "constraint": false,
+          "keyName": "role_perspectives_live_role_global_uq",
           "primary": false,
-          "unique": true
+          "unique": false,
+          "expression": "create unique index \"role_perspectives_live_role_global_uq\" on \"role_perspectives\" (\"role_id\", \"table_id\", \"name\") where \"deleted_at\" is null and \"tenant_id\" is null and \"organization_id\" is null"
+        },
+        {
+          "columnNames": [],
+          "composite": false,
+          "constraint": false,
+          "keyName": "role_perspectives_live_role_org_only_uq",
+          "primary": false,
+          "unique": false,
+          "expression": "create unique index \"role_perspectives_live_role_org_only_uq\" on \"role_perspectives\" (\"role_id\", \"organization_id\", \"table_id\", \"name\") where \"deleted_at\" is null and \"tenant_id\" is null and \"organization_id\" is not null"
+        },
+        {
+          "columnNames": [],
+          "composite": false,
+          "constraint": false,
+          "keyName": "role_perspectives_live_role_org_uq",
+          "primary": false,
+          "unique": false,
+          "expression": "create unique index \"role_perspectives_live_role_org_uq\" on \"role_perspectives\" (\"role_id\", \"tenant_id\", \"organization_id\", \"table_id\", \"name\") where \"deleted_at\" is null and \"tenant_id\" is not null and \"organization_id\" is not null"
+        },
+        {
+          "columnNames": [],
+          "composite": false,
+          "constraint": false,
+          "keyName": "role_perspectives_live_role_tenant_uq",
+          "primary": false,
+          "unique": false,
+          "expression": "create unique index \"role_perspectives_live_role_tenant_uq\" on \"role_perspectives\" (\"role_id\", \"tenant_id\", \"table_id\", \"name\") where \"deleted_at\" is null and \"tenant_id\" is not null and \"organization_id\" is null"
         },
         {
           "columnNames": [
@@ -455,4 +499,4 @@
   ],
   "views": [],
   "nativeEnums": {}
-}
+}

package/src/modules/perspectives/migrations/Migration20260619120000_perspectives_live_row_uniqueness.ts

@@ -0,0 +1,65 @@
+import { Migration } from '@mikro-orm/migrations';
+
+export class Migration20260619120000_perspectives_live_row_uniqueness extends Migration {
+
+  override async up(): Promise<void> {
+    this.addSql(`
+      with ranked as (
+        select id,
+               row_number() over (
+                 partition by user_id, tenant_id, organization_id, table_id, name
+                 order by coalesce(updated_at, created_at) desc, created_at desc, id desc
+               ) as rn
+        from perspectives
+        where deleted_at is null
+      )
+      update perspectives
+      set deleted_at = now(), is_default = false
+      from ranked
+      where perspectives.id = ranked.id and ranked.rn > 1;
+    `);
+    this.addSql(`alter table "perspectives" drop constraint if exists "perspectives_user_id_tenant_id_organization_id_ta_2d725_unique";`);
+    this.addSql(`alter table "perspectives" drop constraint if exists "perspectives_user_id_tenant_id_organization_id_ta_0c702_unique";`);
+    this.addSql(`create unique index if not exists "perspectives_live_user_org_uq" on "perspectives" ("user_id", "tenant_id", "organization_id", "table_id", "name") where "deleted_at" is null and "tenant_id" is not null and "organization_id" is not null;`);
+    this.addSql(`create unique index if not exists "perspectives_live_user_tenant_uq" on "perspectives" ("user_id", "tenant_id", "table_id", "name") where "deleted_at" is null and "tenant_id" is not null and "organization_id" is null;`);
+    this.addSql(`create unique index if not exists "perspectives_live_user_org_only_uq" on "perspectives" ("user_id", "organization_id", "table_id", "name") where "deleted_at" is null and "tenant_id" is null and "organization_id" is not null;`);
+    this.addSql(`create unique index if not exists "perspectives_live_user_global_uq" on "perspectives" ("user_id", "table_id", "name") where "deleted_at" is null and "tenant_id" is null and "organization_id" is null;`);
+
+    this.addSql(`
+      with ranked as (
+        select id,
+               row_number() over (
+                 partition by role_id, tenant_id, organization_id, table_id, name
+                 order by coalesce(updated_at, created_at) desc, created_at desc, id desc
+               ) as rn
+        from role_perspectives
+        where deleted_at is null
+      )
+      update role_perspectives
+      set deleted_at = now(), is_default = false
+      from ranked
+      where role_perspectives.id = ranked.id and ranked.rn > 1;
+    `);
+    this.addSql(`alter table "role_perspectives" drop constraint if exists "role_perspectives_role_id_tenant_id_organization__c5467_unique";`);
+    this.addSql(`alter table "role_perspectives" drop constraint if exists "role_perspectives_role_id_tenant_id_organization__f0fc6_unique";`);
+    this.addSql(`create unique index if not exists "role_perspectives_live_role_org_uq" on "role_perspectives" ("role_id", "tenant_id", "organization_id", "table_id", "name") where "deleted_at" is null and "tenant_id" is not null and "organization_id" is not null;`);
+    this.addSql(`create unique index if not exists "role_perspectives_live_role_tenant_uq" on "role_perspectives" ("role_id", "tenant_id", "table_id", "name") where "deleted_at" is null and "tenant_id" is not null and "organization_id" is null;`);
+    this.addSql(`create unique index if not exists "role_perspectives_live_role_org_only_uq" on "role_perspectives" ("role_id", "organization_id", "table_id", "name") where "deleted_at" is null and "tenant_id" is null and "organization_id" is not null;`);
+    this.addSql(`create unique index if not exists "role_perspectives_live_role_global_uq" on "role_perspectives" ("role_id", "table_id", "name") where "deleted_at" is null and "tenant_id" is null and "organization_id" is null;`);
+  }
+
+  override async down(): Promise<void> {
+    this.addSql(`drop index if exists "perspectives_live_user_org_uq";`);
+    this.addSql(`drop index if exists "perspectives_live_user_tenant_uq";`);
+    this.addSql(`drop index if exists "perspectives_live_user_org_only_uq";`);
+    this.addSql(`drop index if exists "perspectives_live_user_global_uq";`);
+    this.addSql(`alter table "perspectives" add constraint "perspectives_user_id_tenant_id_organization_id_ta_2d725_unique" unique ("user_id", "tenant_id", "organization_id", "table_id", "name");`);
+
+    this.addSql(`drop index if exists "role_perspectives_live_role_org_uq";`);
+    this.addSql(`drop index if exists "role_perspectives_live_role_tenant_uq";`);
+    this.addSql(`drop index if exists "role_perspectives_live_role_org_only_uq";`);
+    this.addSql(`drop index if exists "role_perspectives_live_role_global_uq";`);
+    this.addSql(`alter table "role_perspectives" add constraint "role_perspectives_role_id_tenant_id_organization__c5467_unique" unique ("role_id", "tenant_id", "organization_id", "table_id", "name");`);
+  }
+
+}

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

@@ -296,6 +296,23 @@ export async function saveUserPerspective(
       current: entity.updatedAt ?? null,
       request: options.request ?? null,
     })
+    if (entity.name !== input.name) {
+      const duplicate = await em.findOne(Perspective, {
+        userId: scope.userId,
+        tenantId,
+        organizationId,
+        tableId,
+        name: input.name,
+        id: { $ne: entity.id } as any,
+        deletedAt: null,
+      })
+      if (duplicate) {
+        throw new CrudHttpError(409, {
+          error: 'A view with this name already exists.',
+          code: 'duplicate_name',
+        })
+      }
+    }
   } else {
     entity = await em.findOne(Perspective, {
       userId: scope.userId,

package/src/modules/planner/commands/availability-weekly.ts

@@ -2,17 +2,27 @@ import type { CommandHandler } from '@open-mercato/shared/lib/commands'
 import { registerCommand } from '@open-mercato/shared/lib/commands'
 import type { EntityManager } from '@mikro-orm/postgresql'
 import { parseAvailabilityRuleWindow } from '@open-mercato/core/modules/planner/lib/availabilitySchedule'
-import { PlannerAvailabilityRule } from '../data/entities'
+import { PlannerAvailabilityRule, PlannerAvailabilityRuleSet } from '../data/entities'
 import {
   plannerAvailabilityWeeklyReplaceSchema,
   type PlannerAvailabilityWeeklyReplaceInput,
 } from '../data/validators'
 import { resolveTranslations } from '@open-mercato/shared/lib/i18n/server'
 import type { PlannerAvailabilityKind, PlannerAvailabilitySubjectType } from '../data/entities'
+import {
+  enforceCommandOptimisticLock,
+  enforceRecordGoneIsConflict,
+} from '@open-mercato/shared/lib/crud/optimistic-lock-command'
 import { ensureOrganizationScope, ensureTenantScope, extractUndoPayload } from './shared'
 
 const AVAILABILITY_RULE_RESOURCE_KIND = 'planner.availability.rule'
 
+// Canonical resource kind for the parent rule set, matching the tag the CRUD
+// factory derives for `planner.availability-rule-sets.*` commands. Weekly
+// replace mutates the rule set's child `availability_rules`, so the parent is
+// the optimistic-lock consistency boundary (document-aggregate pattern).
+const AVAILABILITY_RULE_SET_RESOURCE_KIND = 'planner.availability.rule.set'
+
 const DAY_CODES = ['SU', 'MO', 'TU', 'WE', 'TH', 'FR', 'SA']
 
 type AvailabilityRuleSnapshot = {
@@ -164,6 +174,38 @@ const replaceWeeklyAvailabilityCommand: CommandHandler<PlannerAvailabilityWeekly
     const now = new Date()
 
     await em.transactional(async (trx) => {
+      // The weekly rules of a rule set are a sub-resource of that rule set: the
+      // parent is the optimistic-lock consistency boundary. Guard the parent's
+      // version (so a stale weekly save loses to a concurrent rule-set
+      // change/delete) and bump its `updated_at` after the replace (so a
+      // concurrent rule-set delete/update with a stale token conflicts). See #2927.
+      let ruleSet: PlannerAvailabilityRuleSet | null = null
+      if (parsed.subjectType === 'ruleset') {
+        ruleSet = await trx.findOne(PlannerAvailabilityRuleSet, {
+          id: parsed.subjectId,
+          tenantId: parsed.tenantId,
+          organizationId: parsed.organizationId,
+          deletedAt: null,
+        })
+        if (ruleSet) {
+          enforceCommandOptimisticLock({
+            resourceKind: AVAILABILITY_RULE_SET_RESOURCE_KIND,
+            resourceId: ruleSet.id,
+            current: ruleSet.updatedAt,
+            request: ctx.request ?? null,
+          })
+        } else {
+          // The rule set was deleted concurrently. When the client opted into
+          // optimistic locking, surface the unified conflict instead of
+          // silently writing orphan rules; otherwise preserve legacy behavior.
+          enforceRecordGoneIsConflict({
+            resourceKind: AVAILABILITY_RULE_SET_RESOURCE_KIND,
+            resourceId: parsed.subjectId,
+            request: ctx.request ?? null,
+          })
+        }
+      }
+
       const existing = await trx.find(PlannerAvailabilityRule, {
         tenantId: parsed.tenantId,
         organizationId: parsed.organizationId,
@@ -207,6 +249,11 @@ const replaceWeeklyAvailabilityCommand: CommandHandler<PlannerAvailabilityWeekly
         trx.persist(record)
       })
 
+      if (ruleSet) {
+        ruleSet.updatedAt = now
+        trx.persist(ruleSet)
+      }
+
       await trx.flush()
     })
 

package/src/modules/planner/components/AvailabilityRulesEditor.tsx

@@ -857,21 +857,31 @@ export function AvailabilityRulesEditor({
     if (!subjectIdForRules) return
     if (weeklyHasErrors) return
 
+    // Weekly rules of a rule set are a sub-resource of that rule set. Send the
+    // parent's expected version so a concurrent rule-set change/delete is
+    // detected, and refresh it afterwards because the server bumps the rule
+    // set's `updated_at` on a successful replace (#2927).
+    const parentRuleSet = subjectForRules === 'ruleset'
+      ? (ruleSets.find((entry) => entry.id === subjectIdForRules) ?? null)
+      : null
+
     const shouldSkipRefresh = Boolean(options?.skipRefresh)
     setIsWeeklyAutoSaving(options?.silentSuccess === true)
     try {
       const windows = buildWeeklyPayload(normalizeWeeklyWindows(weeklyWindowsRef.current))
       await runMutation({
-        operation: () => apiCallOrThrow('/api/planner/availability-weekly', {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({
-            subjectType: subjectForRules,
-            subjectId: subjectIdForRules,
-            timezone,
-            windows,
-          }),
-        }, { errorMessage: listLabels.saveWeeklyError }),
+        operation: () => withOptimisticLockForRuleSet(parentRuleSet, () => (
+          apiCallOrThrow('/api/planner/availability-weekly', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+              subjectType: subjectForRules,
+              subjectId: subjectIdForRules,
+              timezone,
+              windows,
+            }),
+          }, { errorMessage: listLabels.saveWeeklyError })
+        )),
         context: mutationContext,
         mutationPayload: { action: 'save-weekly', subjectType: subjectForRules, subjectId: subjectIdForRules },
       })
@@ -884,7 +894,13 @@ export function AvailabilityRulesEditor({
         await refreshAvailability()
         await refreshRuleSetRules()
       }
+      if (parentRuleSet) {
+        await refreshRuleSets()
+      }
     } catch (error) {
+      if (surfaceRecordConflict(error, t)) {
+        return
+      }
       const message = error instanceof Error ? error.message : listLabels.saveWeeklyError
       flash(message, 'error')
     } finally {
@@ -895,9 +911,12 @@ export function AvailabilityRulesEditor({
     listLabels.saveWeeklySuccess,
     refreshAvailability,
     refreshRuleSetRules,
+    refreshRuleSets,
+    ruleSets,
     effectiveRulesetId,
     subjectId,
     subjectType,
+    t,
     timezone,
     usingRuleSet,
     weeklyHasErrors,
@@ -1161,6 +1180,7 @@ export function AvailabilityRulesEditor({
       refreshRuleSets,
       onSuccess: () => flash(listLabels.ruleSetDeleteSuccess, 'success'),
       onError: (error) => {
+        if (surfaceRecordConflict(error, t)) return
         console.error('planner.availability-rule-sets.delete', error)
         const normalized = normalizeCrudServerError(error)
         flash(normalized.message ?? listLabels.ruleSetDeleteError, 'error')
@@ -1178,6 +1198,7 @@ export function AvailabilityRulesEditor({
     refreshRuleSets,
     ruleSets,
     rulesetId,
+    t,
     mutationContext,
     runMutation,
   ])

package/src/modules/progress/api/active/route.ts

@@ -20,7 +20,7 @@ export async function GET(req: Request) {
 
   const ctx = { tenantId: auth.tenantId, organizationId: auth.orgId }
 
-  await progressService.markStaleJobsFailed(auth.tenantId)
+  await progressService.markStaleJobsFailed(auth.tenantId, undefined, auth.orgId)
 
   const [jobs, recentlyCompleted] = await Promise.all([
     progressService.getActiveJobs(ctx),