@open-mercato/core 0.4.2-canary-f075c3eb92 → 0.4.2-canary-8a04af8836

package/src/modules/configs/lib/upgrade-actions.ts

@@ -1,95 +1,15 @@
-import { runWithCacheTenant } from '@open-mercato/cache'
 import type { EntityManager } from '@mikro-orm/postgresql'
-import type { AwilixContainer } from 'awilix'
-import { Role, RoleAcl } from '@open-mercato/core/modules/auth/data/entities'
-import type { RbacService } from '@open-mercato/core/modules/auth/services/rbacService'
-import { reindexModules } from '@open-mercato/core/modules/configs/lib/reindex-helpers'
-// Optional module imports are loaded dynamically inside each upgrade action
-// so the app does not crash when a module is disabled.
-import { collectCrudCacheStats, purgeCrudCacheSegment } from '@open-mercato/shared/lib/crud/cache-stats'
-import { isCrudCacheEnabled, resolveCrudCache } from '@open-mercato/shared/lib/crud/cache'
 import * as semver from 'semver'
-import type { VectorIndexService } from '@open-mercato/search/vector'
-import { EncryptionMap } from '@open-mercato/core/modules/entities/data/entities'
-import { DEFAULT_ENCRYPTION_MAPS } from '@open-mercato/core/modules/entities/lib/encryptionDefaults'
-import type { TenantDataEncryptionService } from '@open-mercato/shared/lib/encryption/tenantDataEncryptionService'
-
-function resolveVectorService(container: AwilixContainer): VectorIndexService | null {
-  try {
-    return container.resolve<VectorIndexService>('vectorIndexService')
-  } catch {
-    return null
-  }
-}
-
-function resolveEncryptionService(container: AwilixContainer): TenantDataEncryptionService | null {
-  try {
-    return container.resolve<TenantDataEncryptionService>('tenantEncryptionService')
-  } catch {
-    return null
-  }
-}
-
-async function ensureVectorSearchEncryptionMap(
-  em: EntityManager,
-  tenantId: string,
-  organizationId: string | null,
-): Promise<boolean> {
-  const spec = DEFAULT_ENCRYPTION_MAPS.find((entry) => entry.entityId === 'vector:vector_search')
-  const required = spec?.fields ?? []
-  if (!required.length) return false
-
-  const repo = em.getRepository(EncryptionMap)
-  const existing = await repo.findOne({
-    entityId: 'vector:vector_search',
-    tenantId,
-    organizationId,
-    deletedAt: null,
-  })
-
-  if (!existing) {
-    em.persist(
-      em.create(EncryptionMap, {
-        entityId: 'vector:vector_search',
-        tenantId,
-        organizationId,
-        fieldsJson: required,
-        isActive: true,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-      }),
-    )
-    await em.flush()
-    return true
-  }
-
-  const existingFields = Array.isArray(existing.fieldsJson) ? existing.fieldsJson : []
-  const byField = new Map<string, { field: string; hashField?: string | null }>()
-  for (const item of existingFields) {
-    if (!item?.field) continue
-    byField.set(item.field, item)
-  }
-  for (const req of required) {
-    if (!req?.field) continue
-    if (byField.has(req.field)) continue
-    byField.set(req.field, req)
-  }
-
-  const merged = Array.from(byField.values())
-  const changed = merged.length !== existingFields.length
-  if (!changed && existing.isActive) return false
-
-  existing.fieldsJson = merged
-  existing.isActive = true
-  existing.updatedAt = new Date()
-  await em.flush()
-  return true
-}
+import { getModules } from '@open-mercato/shared/lib/modules/registry'
+import type { Module } from '@open-mercato/shared/modules/registry'
+import type { AppContainer } from '@open-mercato/shared/lib/di/container'
+import { Role, RoleAcl } from '@open-mercato/core/modules/auth/data/entities'
+import { normalizeTenantId } from '@open-mercato/core/modules/auth/lib/tenantAccess'
 
 export type UpgradeActionContext = {
   tenantId: string
   organizationId: string
-  container: AwilixContainer
+  container: AppContainer
   em: EntityManager
 }
 
@@ -121,26 +41,108 @@ export function compareVersions(a: string, b: string): number {
   return semver.compare(cleanA, cleanB)
 }
 
-async function purgeCatalogCrudCache(container: AwilixContainer, tenantId: string | null) {
-  if (!isCrudCacheEnabled()) return
-  const cache = resolveCrudCache(container)
-  if (!cache) return
-  await runWithCacheTenant(tenantId ?? null, async () => {
-    const stats = await collectCrudCacheStats(cache)
-    const catalogSegments = stats.segments.filter((segment) => segment.resource?.startsWith('catalog.'))
-    if (!catalogSegments.length) return
-    for (const segment of catalogSegments) {
-      try {
-        await purgeCrudCacheSegment(cache, segment.segment)
-      } catch (error) {
-        console.warn('[upgrade-actions] failed to purge catalog cache segment', {
-          tenantId,
-          segment: segment.segment,
-          error,
-        })
-      }
-    }
-  })
+type RoleName = 'superadmin' | 'admin' | 'employee'
+
+function collectRoleFeatures(modules: Module[], moduleIds: string[]): Record<RoleName, string[]> {
+  const result: Record<RoleName, string[]> = {
+    superadmin: [],
+    admin: [],
+    employee: [],
+  }
+  const targetIds = new Set(moduleIds)
+  for (const mod of modules) {
+    if (!targetIds.has(mod.id)) continue
+    const roleFeatures = mod.setup?.defaultRoleFeatures
+    if (roleFeatures?.superadmin) result.superadmin.push(...roleFeatures.superadmin)
+    if (roleFeatures?.admin) result.admin.push(...roleFeatures.admin)
+    if (roleFeatures?.employee) result.employee.push(...roleFeatures.employee)
+  }
+  result.superadmin = Array.from(new Set(result.superadmin))
+  result.admin = Array.from(new Set(result.admin))
+  result.employee = Array.from(new Set(result.employee))
+  return result
+}
+
+async function findRoleByName(
+  em: EntityManager,
+  name: string,
+  tenantId: string | null,
+): Promise<Role | null> {
+  const normalizedTenant = normalizeTenantId(tenantId ?? null) ?? null
+  let role = await em.findOne(Role, { name, tenantId: normalizedTenant })
+  if (!role && normalizedTenant !== null) {
+    role = await em.findOne(Role, { name, tenantId: null })
+  }
+  return role
+}
+
+async function ensureRoleAclFor(
+  em: EntityManager,
+  role: Role,
+  tenantId: string,
+  features: string[],
+  options: { isSuperAdmin?: boolean } = {},
+) {
+  const existing = await em.findOne(RoleAcl, { role, tenantId })
+  if (!existing) {
+    const acl = em.create(RoleAcl, {
+      role,
+      tenantId,
+      featuresJson: features,
+      isSuperAdmin: !!options.isSuperAdmin,
+      createdAt: new Date(),
+    })
+    await em.persistAndFlush(acl)
+    return
+  }
+  const currentFeatures = Array.isArray(existing.featuresJson) ? existing.featuresJson : []
+  const merged = Array.from(new Set([...currentFeatures, ...features]))
+  const changed =
+    merged.length !== currentFeatures.length ||
+    merged.some((value, index) => value !== currentFeatures[index])
+  if (changed) existing.featuresJson = merged
+  if (options.isSuperAdmin && !existing.isSuperAdmin) {
+    existing.isSuperAdmin = true
+  }
+  if (changed || options.isSuperAdmin) {
+    await em.persistAndFlush(existing)
+  }
+}
+
+async function ensureRoleAclsForModules(
+  em: EntityManager,
+  tenantId: string,
+  moduleIds: string[],
+) {
+  const modules = getModules()
+  const roleFeatures = collectRoleFeatures(modules, moduleIds)
+  if (!roleFeatures.superadmin.length && !roleFeatures.admin.length && !roleFeatures.employee.length) {
+    return
+  }
+  const normalizedTenant = normalizeTenantId(tenantId) ?? null
+  const [superadminRole, adminRole, employeeRole] = await Promise.all([
+    findRoleByName(em, 'superadmin', normalizedTenant),
+    findRoleByName(em, 'admin', normalizedTenant),
+    findRoleByName(em, 'employee', normalizedTenant),
+  ])
+  if (superadminRole && roleFeatures.superadmin.length) {
+    await ensureRoleAclFor(em, superadminRole, tenantId, roleFeatures.superadmin, { isSuperAdmin: true })
+  }
+  if (adminRole && roleFeatures.admin.length) {
+    await ensureRoleAclFor(em, adminRole, tenantId, roleFeatures.admin)
+  }
+  if (employeeRole && roleFeatures.employee.length) {
+    await ensureRoleAclFor(em, employeeRole, tenantId, roleFeatures.employee)
+  }
+}
+
+async function safeImport<T>(label: string, loader: () => Promise<T>): Promise<T | null> {
+  try {
+    return await loader()
+  } catch (error) {
+    console.warn(`[upgrade-actions] Skipping ${label} because module import failed.`, error)
+    return null
+  }
 }
 
 export const upgradeActions: UpgradeActionDefinition[] = [
@@ -151,64 +153,16 @@ export const upgradeActions: UpgradeActionDefinition[] = [
     ctaKey: 'upgrades.v034.cta',
     successKey: 'upgrades.v034.success',
     loadingKey: 'upgrades.v034.loading',
-    async run({ container, em, tenantId, organizationId }) {
-      let installExampleCatalogData: typeof import('@open-mercato/core/modules/catalog/lib/seeds')['installExampleCatalogData'] | undefined
-      try {
-        const catalogSeeds = await import('@open-mercato/core/modules/catalog/lib/seeds')
-        installExampleCatalogData = catalogSeeds.installExampleCatalogData
-      } catch {
-        console.warn('[upgrade-actions] catalog module not available, skipping catalog example data')
-        return
-      }
-      await installExampleCatalogData(container, { tenantId, organizationId }, em)
-      const vectorService = resolveVectorService(container)
-      await reindexModules(em, ['catalog'], { tenantId, organizationId, vectorService })
-    },
-  },
-  {
-    id: 'configs.upgrades.auth.admin_business_rules_acl',
-    version: '0.3.5',
-    messageKey: 'upgrades.v035.message',
-    ctaKey: 'upgrades.v035.cta',
-    successKey: 'upgrades.v035.success',
-    loadingKey: 'upgrades.v035.loading',
-    async run({ container, em, tenantId }) {
-      const normalizedTenantId = tenantId.trim()
-      await em.transactional(async (tem) => {
-        const adminRole = await tem.findOne(Role, { name: 'admin', tenantId: normalizedTenantId, deletedAt: null })
-        if (!adminRole) return
-
-        const roleAcls = await tem.find(RoleAcl, { role: adminRole, tenantId: normalizedTenantId, deletedAt: null })
-        let touched = false
-        if (!roleAcls.length) {
-          tem.persist(
-            tem.create(RoleAcl, {
-              role: adminRole,
-              tenantId: normalizedTenantId,
-              featuresJson: ['business_rules.*'],
-              isSuperAdmin: false,
-              createdAt: new Date(),
-              updatedAt: new Date(),
-            }),
-          )
-          touched = true
-        }
-
-        for (const acl of roleAcls) {
-          const features = Array.isArray(acl.featuresJson) ? [...acl.featuresJson] : []
-          if (features.includes('business_rules.*')) continue
-          acl.featuresJson = [...features, 'business_rules.*']
-          acl.updatedAt = new Date()
-          touched = true
-        }
-
-        if (touched) {
-          await tem.flush()
-        }
-      })
-
-      const rbac = container.resolve<RbacService>('rbacService')
-      await rbac.invalidateTenantCache(normalizedTenantId)
+    async run(ctx) {
+      const catalogSeeds = await safeImport('catalog examples', () =>
+        import('@open-mercato/core/modules/catalog/lib/seeds')
+      )
+      if (!catalogSeeds?.installExampleCatalogData) return
+      await catalogSeeds.installExampleCatalogData(
+        ctx.container,
+        { tenantId: ctx.tenantId, organizationId: ctx.organizationId },
+        ctx.em,
+      )
     },
   },
   {
@@ -218,51 +172,15 @@ export const upgradeActions: UpgradeActionDefinition[] = [
     ctaKey: 'upgrades.v036.cta',
     successKey: 'upgrades.v036.success',
     loadingKey: 'upgrades.v036.loading',
-    async run({ container, em, tenantId, organizationId }) {
-      let seedSalesExamples: typeof import('@open-mercato/core/modules/sales/seed/examples')['seedSalesExamples'] | undefined
-      try {
-        const salesSeeds = await import('@open-mercato/core/modules/sales/seed/examples')
-        seedSalesExamples = salesSeeds.seedSalesExamples
-      } catch {
-        console.warn('[upgrade-actions] sales module not available, skipping sales example data')
-        return
-      }
-      await em.transactional(async (tem) => {
-        await seedSalesExamples!(tem, container, { tenantId, organizationId })
+    async run(ctx) {
+      const salesSeeds = await safeImport('sales examples', () =>
+        import('@open-mercato/core/modules/sales/seed/examples')
+      )
+      if (!salesSeeds?.seedSalesExamples) return
+      await salesSeeds.seedSalesExamples(ctx.em, ctx.container, {
+        tenantId: ctx.tenantId,
+        organizationId: ctx.organizationId,
       })
-      const vectorService = resolveVectorService(container)
-      await reindexModules(em, ['sales', 'catalog'], { tenantId, organizationId, vectorService })
-      await purgeCatalogCrudCache(container, tenantId)
-    },
-  },
-  {
-    id: 'configs.upgrades.vector.encryption_vector_search',
-    version: '0.3.6',
-    messageKey: 'upgrades.v036_vector_encryption.message',
-    ctaKey: 'upgrades.v036_vector_encryption.cta',
-    successKey: 'upgrades.v036_vector_encryption.success',
-    loadingKey: 'upgrades.v036_vector_encryption.loading',
-    async run({ container, em, tenantId, organizationId }) {
-      const normalizedTenantId = tenantId.trim()
-      const normalizedOrgId = organizationId ?? null
-
-      const encryptionService = resolveEncryptionService(container)
-      if (!encryptionService?.isEnabled?.()) {
-        return
-      }
-
-      const updated = await em.transactional(async (tem) => {
-        return ensureVectorSearchEncryptionMap(tem, normalizedTenantId, normalizedOrgId)
-      })
-
-      if (updated) {
-        await encryptionService.invalidateMap('vector:vector_search', normalizedTenantId, normalizedOrgId)
-      }
-
-      const vectorService = resolveVectorService(container)
-      if (vectorService) {
-        await vectorService.reindexAll({ tenantId: normalizedTenantId, organizationId: normalizedOrgId, purgeFirst: false })
-      }
     },
   },
   {
@@ -272,67 +190,21 @@ export const upgradeActions: UpgradeActionDefinition[] = [
     ctaKey: 'upgrades.v0313.cta',
     successKey: 'upgrades.v0313.success',
     loadingKey: 'upgrades.v0313.loading',
-    async run({ container, em, tenantId, organizationId }) {
-      const normalizedTenantId = tenantId.trim()
-      const scope = { tenantId, organizationId }
-
-      let seedExampleCurrencies: typeof import('@open-mercato/core/modules/currencies/lib/seeds')['seedExampleCurrencies'] | undefined
-      try {
-        const currenciesSeeds = await import('@open-mercato/core/modules/currencies/lib/seeds')
-        seedExampleCurrencies = currenciesSeeds.seedExampleCurrencies
-      } catch {
-        console.warn('[upgrade-actions] currencies module not available, skipping currency seeding')
+    async run(ctx) {
+      const currenciesSeeds = await safeImport('currencies examples', () =>
+        import('@open-mercato/core/modules/currencies/lib/seeds')
+      )
+      const workflowsSeeds = await safeImport('workflows examples', () =>
+        import('@open-mercato/core/modules/workflows/lib/seeds')
+      )
+      const scope = { tenantId: ctx.tenantId, organizationId: ctx.organizationId }
+      if (currenciesSeeds?.seedExampleCurrencies) {
+        await currenciesSeeds.seedExampleCurrencies(ctx.em, scope)
       }
-
-      let seedExampleWorkflows: typeof import('@open-mercato/core/modules/workflows/lib/seeds')['seedExampleWorkflows'] | undefined
-      try {
-        const workflowsSeeds = await import('@open-mercato/core/modules/workflows/lib/seeds')
-        seedExampleWorkflows = workflowsSeeds.seedExampleWorkflows
-      } catch {
-        console.warn('[upgrade-actions] workflows module not available, skipping workflow seeding')
+      if (workflowsSeeds?.seedExampleWorkflows) {
+        await workflowsSeeds.seedExampleWorkflows(ctx.em, scope)
       }
-
-      await em.transactional(async (tem) => {
-        if (seedExampleCurrencies) await seedExampleCurrencies(tem, scope)
-        if (seedExampleWorkflows) await seedExampleWorkflows(tem, scope)
-
-        const adminRole = await tem.findOne(Role, { name: 'admin', tenantId: normalizedTenantId, deletedAt: null })
-        if (!adminRole) return
-
-        const roleAcls = await tem.find(RoleAcl, { role: adminRole, tenantId: normalizedTenantId, deletedAt: null })
-        let touched = false
-        if (!roleAcls.length) {
-          tem.persist(
-            tem.create(RoleAcl, {
-              role: adminRole,
-              tenantId: normalizedTenantId,
-              featuresJson: ['search.*', 'feature_toggles.*', 'currencies.*'],
-              isSuperAdmin: false,
-              createdAt: new Date(),
-              updatedAt: new Date(),
-            }),
-          )
-          touched = true
-        }
-
-        for (const acl of roleAcls) {
-          const features = Array.isArray(acl.featuresJson) ? [...acl.featuresJson] : []
-          const nextFeatures = new Set(features)
-          nextFeatures.add('search.*')
-          nextFeatures.add('feature_toggles.*')
-          nextFeatures.add('currencies.*')
-          if (nextFeatures.size === features.length) continue
-          acl.featuresJson = Array.from(nextFeatures)
-          acl.updatedAt = new Date()
-          touched = true
-        }
-
-        if (touched) {
-          await tem.flush()
-        }
-      })
-      const rbac = container.resolve<RbacService>('rbacService')
-      await rbac.invalidateTenantCache(normalizedTenantId)
+      await ensureRoleAclsForModules(ctx.em, ctx.tenantId, ['currencies', 'workflows'])
     },
   },
   {
@@ -342,93 +214,27 @@ export const upgradeActions: UpgradeActionDefinition[] = [
     ctaKey: 'upgrades.v041.cta',
     successKey: 'upgrades.v041.success',
     loadingKey: 'upgrades.v041.loading',
-    async run({ container, em, tenantId, organizationId }) {
-      const normalizedTenantId = tenantId.trim()
-      const scope = { tenantId, organizationId }
-
-      let seedPlannerAvailabilityRuleSetDefaults: typeof import('@open-mercato/core/modules/planner/lib/seeds')['seedPlannerAvailabilityRuleSetDefaults'] | undefined
-      let seedPlannerUnavailabilityReasons: typeof import('@open-mercato/core/modules/planner/lib/seeds')['seedPlannerUnavailabilityReasons'] | undefined
-      try {
-        const plannerSeeds = await import('@open-mercato/core/modules/planner/lib/seeds')
-        seedPlannerAvailabilityRuleSetDefaults = plannerSeeds.seedPlannerAvailabilityRuleSetDefaults
-        seedPlannerUnavailabilityReasons = plannerSeeds.seedPlannerUnavailabilityReasons
-      } catch {
-        console.warn('[upgrade-actions] planner module not available, skipping planner seeding')
+    async run(ctx) {
+      const plannerSeeds = await safeImport('planner examples', () =>
+        import('@open-mercato/core/modules/planner/lib/seeds')
+      )
+      const staffSeeds = await safeImport('staff examples', () =>
+        import('@open-mercato/core/modules/staff/lib/seeds')
+      )
+      const resourcesSeeds = await safeImport('resources examples', () =>
+        import('@open-mercato/core/modules/resources/lib/seeds')
+      )
+      const scope = { tenantId: ctx.tenantId, organizationId: ctx.organizationId }
+      if (plannerSeeds?.seedPlannerAvailabilityRuleSetDefaults) {
+        await plannerSeeds.seedPlannerAvailabilityRuleSetDefaults(ctx.em, scope)
       }
-
-      let seedStaffTeamExamples: typeof import('@open-mercato/core/modules/staff/lib/seeds')['seedStaffTeamExamples'] | undefined
-      try {
-        const staffSeeds = await import('@open-mercato/core/modules/staff/lib/seeds')
-        seedStaffTeamExamples = staffSeeds.seedStaffTeamExamples
-      } catch {
-        console.warn('[upgrade-actions] staff module not available, skipping staff seeding')
+      if (staffSeeds?.seedStaffTeamExamples) {
+        await staffSeeds.seedStaffTeamExamples(ctx.em, scope)
       }
-
-      let seedResourcesAddressTypes: typeof import('@open-mercato/core/modules/resources/lib/seeds')['seedResourcesAddressTypes'] | undefined
-      let seedResourcesCapacityUnits: typeof import('@open-mercato/core/modules/resources/lib/seeds')['seedResourcesCapacityUnits'] | undefined
-      let seedResourcesResourceExamples: typeof import('@open-mercato/core/modules/resources/lib/seeds')['seedResourcesResourceExamples'] | undefined
-      try {
-        const resourcesSeeds = await import('@open-mercato/core/modules/resources/lib/seeds')
-        seedResourcesAddressTypes = resourcesSeeds.seedResourcesAddressTypes
-        seedResourcesCapacityUnits = resourcesSeeds.seedResourcesCapacityUnits
-        seedResourcesResourceExamples = resourcesSeeds.seedResourcesResourceExamples
-      } catch {
-        console.warn('[upgrade-actions] resources module not available, skipping resources seeding')
+      if (resourcesSeeds?.seedResourcesResourceExamples) {
+        await resourcesSeeds.seedResourcesResourceExamples(ctx.em, scope)
       }
-
-      await em.transactional(async (tem) => {
-        if (seedPlannerAvailabilityRuleSetDefaults) await seedPlannerAvailabilityRuleSetDefaults(tem, scope)
-        if (seedPlannerUnavailabilityReasons) await seedPlannerUnavailabilityReasons(tem, scope)
-        if (seedStaffTeamExamples) await seedStaffTeamExamples(tem, scope)
-        if (seedResourcesCapacityUnits) await seedResourcesCapacityUnits(tem, scope)
-        if (seedResourcesAddressTypes) await seedResourcesAddressTypes(tem, scope)
-        if (seedResourcesResourceExamples) await seedResourcesResourceExamples(tem, scope)
-
-        const adminRole = await tem.findOne(Role, { name: 'admin', tenantId: normalizedTenantId, deletedAt: null })
-        if (!adminRole) return
-
-        const roleAcls = await tem.find(RoleAcl, { role: adminRole, tenantId: normalizedTenantId, deletedAt: null })
-        const addedFeatures = [
-          'staff.*',
-          'staff.leave_requests.manage',
-          'resources.*',
-          'planner.*',
-        ]
-        let touched = false
-        if (!roleAcls.length) {
-          tem.persist(
-            tem.create(RoleAcl, {
-              role: adminRole,
-              tenantId: normalizedTenantId,
-              featuresJson: addedFeatures,
-              isSuperAdmin: false,
-              createdAt: new Date(),
-              updatedAt: new Date(),
-            }),
-          )
-          touched = true
-        }
-
-        for (const acl of roleAcls) {
-          const features = Array.isArray(acl.featuresJson) ? [...acl.featuresJson] : []
-          const nextFeatures = new Set(features)
-          for (const feature of addedFeatures) nextFeatures.add(feature)
-          if (nextFeatures.size === features.length) continue
-          acl.featuresJson = Array.from(nextFeatures)
-          acl.updatedAt = new Date()
-          touched = true
-        }
-
-        if (touched) {
-          await tem.flush()
-        }
-      })
-
-      const rbac = container.resolve<RbacService>('rbacService')
-      await rbac.invalidateTenantCache(normalizedTenantId)
-
-      const vectorService = resolveVectorService(container)
-      await reindexModules(em, ['planner', 'staff', 'resources'], { tenantId, organizationId, vectorService })
+      await ensureRoleAclsForModules(ctx.em, ctx.tenantId, ['planner', 'staff', 'resources'])
     },
   },
 ]

package/src/modules/currencies/backend/currencies/page.tsx

@@ -256,12 +256,14 @@ export default function CurrenciesPage() {
             <RowActions
               items={[
                 {
+                  id: 'edit',
                   label: t('common.edit'),
                   href: `/backend/currencies/${row.id}`,
                 },
                 ...(!row.isBase
                   ? [
                       {
+                        id: 'set-base',
                         label: t('currencies.list.actions.setBase'),
                         onSelect: () => handleSetBase(row),
                       },
@@ -270,6 +272,7 @@ export default function CurrenciesPage() {
                 ...(!row.isBase
                   ? [
                       {
+                        id: 'delete',
                         label: t('common.delete'),
                         destructive: true,
                         onSelect: () => handleDelete(row),

package/src/modules/currencies/backend/exchange-rates/page.tsx

@@ -279,10 +279,12 @@ export default function ExchangeRatesPage() {
             <RowActions
               items={[
                 {
+                  id: 'edit',
                   label: t('common.edit'),
                   href: `/backend/exchange-rates/${row.id}`,
                 },
                 {
+                  id: 'delete',
                   label: t('common.delete'),
                   destructive: true,
                   onSelect: () => handleDelete(row),

package/src/modules/customers/backend/customers/companies/page.tsx

@@ -597,14 +597,17 @@ export default function CustomersCompaniesPage() {
             <RowActions
               items={[
                 {
+                  id: 'view',
                   label: t('customers.companies.list.actions.view'),
                   onSelect: () => { router.push(`/backend/customers/companies/${row.id}`) },
                 },
                 {
+                  id: 'open-new-tab',
                   label: t('customers.companies.list.actions.openInNewTab'),
                   onSelect: () => window.open(`/backend/customers/companies/${row.id}`, '_blank', 'noopener'),
                 },
                 {
+                  id: 'delete',
                   label: t('customers.companies.list.actions.delete'),
                   destructive: true,
                   onSelect: () => handleDelete(row),

package/src/modules/customers/backend/customers/deals/page.tsx

@@ -889,10 +889,12 @@ export default function CustomersDealsPage() {
               <RowActions
                 items={[
                   {
+                    id: 'edit',
                     label: t('customers.deals.list.actions.edit', 'Edit'),
                     onSelect: () => { router.push(`/backend/customers/deals/${row.id}`) },
                   },
                   {
+                    id: 'open-new-tab',
                     label: t('customers.deals.list.actions.openInNewTab', 'Open in new tab'),
                     onSelect: () => {
                       if (typeof window !== 'undefined') {
@@ -901,6 +903,7 @@ export default function CustomersDealsPage() {
                     },
                   },
                   {
+                    id: 'delete',
                     label: isDeleting
                       ? t('customers.deals.list.actions.deleting', 'Deleting…')
                       : t('customers.deals.list.actions.delete', 'Delete'),

package/src/modules/customers/backend/customers/people/page.tsx

@@ -614,14 +614,17 @@ export default function CustomersPeoplePage() {
             <RowActions
               items={[
                 {
+                  id: 'view',
                   label: t('customers.people.list.actions.view'),
                   onSelect: () => { router.push(`/backend/customers/people/${row.id}`) },
                 },
                 {
+                  id: 'open-new-tab',
                   label: t('customers.people.list.actions.openInNewTab'),
                   onSelect: () => window.open(`/backend/customers/people/${row.id}`, '_blank', 'noopener'),
                 },
                 {
+                  id: 'delete',
                   label: t('customers.people.list.actions.delete'),
                   destructive: true,
                   onSelect: () => handleDelete(row),