@open-mercato/core 0.4.2-canary-c84cff7ed5 → 0.4.2-canary-02d8ce2991

package/src/modules/dashboards/components/WidgetVisibilityEditor.tsx

@@ -44,9 +44,13 @@ type UserProps = BaseProps & {
 
 type WidgetVisibilityEditorProps = RoleProps | UserProps
 
+export type WidgetVisibilityEditorHandle = {
+  save: () => Promise<void>
+}
+
 const EMPTY: string[] = []
 
-export function WidgetVisibilityEditor(props: WidgetVisibilityEditorProps) {
+export const WidgetVisibilityEditor = React.forwardRef<WidgetVisibilityEditorHandle, WidgetVisibilityEditorProps>(function WidgetVisibilityEditor(props, ref) {
   const t = useT()
   const { kind, targetId, tenantId, organizationId } = props
   const [catalog, setCatalog] = React.useState<WidgetCatalogItem[]>([])
@@ -60,6 +64,15 @@ export function WidgetVisibilityEditor(props: WidgetVisibilityEditorProps) {
   const [originalMode, setOriginalMode] = React.useState<'inherit' | 'override'>('inherit')
   const [effective, setEffective] = React.useState<string[]>(EMPTY)
 
+  const dirty = React.useMemo(() => {
+    if (kind === 'user') {
+      if (mode !== originalMode) return true
+      if (mode === 'override') return selected.join('|') !== original.join('|')
+      return false
+    }
+    return selected.join('|') !== original.join('|')
+  }, [kind, mode, original, originalMode, selected])
+
   const loadCatalog = React.useCallback(async () => {
     const data = await readApiResultOrThrow<{ items?: unknown[] }>(
       '/api/dashboards/widgets/catalog',
@@ -149,6 +162,9 @@ export function WidgetVisibilityEditor(props: WidgetVisibilityEditorProps) {
   }, [original, originalMode])
 
   const save = React.useCallback(async () => {
+    if (loading) return
+    if (error && catalog.length === 0) return
+    if (!dirty) return
     setSaving(true)
     setError(null)
     try {
@@ -202,16 +218,9 @@ export function WidgetVisibilityEditor(props: WidgetVisibilityEditorProps) {
     } finally {
       setSaving(false)
     }
-  }, [kind, mode, organizationId, selected, t, targetId, tenantId])
+  }, [catalog.length, dirty, error, kind, loading, mode, organizationId, selected, t, targetId, tenantId])
 
-  const dirty = React.useMemo(() => {
-    if (kind === 'user') {
-      if (mode !== originalMode) return true
-      if (mode === 'override') return selected.join('|') !== original.join('|')
-      return false
-    }
-    return selected.join('|') !== original.join('|')
-  }, [kind, mode, original, originalMode, selected])
+  React.useImperativeHandle(ref, () => ({ save }), [save])
 
   if (loading) {
     return (
@@ -297,4 +306,6 @@ export function WidgetVisibilityEditor(props: WidgetVisibilityEditorProps) {
       </div>
     </div>
   )
-}
+})
+
+WidgetVisibilityEditor.displayName = 'WidgetVisibilityEditor'

package/src/modules/dashboards/services/widgetDataService.ts

@@ -1,6 +1,8 @@
 import type { EntityManager } from '@mikro-orm/postgresql'
 import type { CacheStrategy } from '@open-mercato/cache'
 import { createHash } from 'node:crypto'
+import { resolveTenantEncryptionService } from '@open-mercato/shared/lib/encryption/customFieldValues'
+import { resolveEntityIdFromMetadata } from '@open-mercato/shared/lib/encryption/entityIds'
 import {
   type DateRangePreset,
   resolveDateRange,
@@ -296,11 +298,29 @@ export class WidgetDataService {
 
     try {
       const labelRows = await this.em.getConnection().execute(sql, params)
+      const meta = this.resolveEntityMetadata(config.table)
+      const entityId = this.resolveEntityId(meta)
+      const encryptionService = resolveTenantEncryptionService(this.em as any)
+      const organizationId = this.resolveOrganizationId()
 
       const labelMap = new Map<string, string>()
       for (const row of labelRows as Array<{ id: string; label: string | null }>) {
-        if (row.id && row.label != null && row.label !== '') {
-          labelMap.set(row.id, row.label)
+        let labelValue = row.label
+        if (entityId && encryptionService?.isEnabled() && labelValue != null) {
+          const decrypted = await encryptionService.decryptEntityPayload(
+            entityId,
+            { [config.labelColumn]: labelValue },
+            this.scope.tenantId,
+            organizationId,
+          )
+          const resolved = decrypted[config.labelColumn]
+          if (typeof resolved === 'string' || typeof resolved === 'number') {
+            labelValue = String(resolved)
+          }
+        }
+
+        if (row.id && labelValue != null && labelValue !== '') {
+          labelMap.set(row.id, labelValue)
         }
       }
 
@@ -317,6 +337,36 @@ export class WidgetDataService {
       }))
     }
   }
+
+  private resolveOrganizationId(): string | null {
+    if (!this.scope.organizationIds || this.scope.organizationIds.length !== 1) return null
+    return this.scope.organizationIds[0] ?? null
+  }
+
+  private resolveEntityMetadata(tableName: string): Record<string, any> | null {
+    const registry = (this.em as any)?.getMetadata?.()
+    if (!registry) return null
+    const entries =
+      (typeof registry.getAll === 'function' && registry.getAll()) ||
+      (Array.isArray(registry.metadata) ? registry.metadata : Object.values(registry.metadata ?? {}))
+    const metas = Array.isArray(entries) ? entries : Object.values(entries ?? {})
+    const match = metas.find((meta: any) => {
+      const table = meta?.tableName ?? meta?.collection
+      if (typeof table !== 'string') return false
+      if (table === tableName) return true
+      return table.split('.').pop() === tableName
+    })
+    return match ?? null
+  }
+
+  private resolveEntityId(meta: Record<string, any> | null): string | null {
+    if (!meta) return null
+    try {
+      return resolveEntityIdFromMetadata(meta as any)
+    } catch {
+      return null
+    }
+  }
 }
 
 export function createWidgetDataService(

package/src/modules/notifications/__tests__/deliver-notification.test.ts

@@ -0,0 +1,195 @@
+import type { Notification } from '../data/entities'
+import type { NotificationDeliveryConfig } from '../lib/deliveryConfig'
+import type { NotificationDeliveryStrategy } from '../lib/deliveryStrategies'
+
+const sendEmail = jest.fn()
+const getNotificationDeliveryStrategies = jest.fn()
+const resolveNotificationDeliveryConfig = jest.fn()
+const resolveNotificationPanelUrl = jest.fn()
+const findOneWithDecryption = jest.fn()
+const NotificationEmail = jest.fn(() => 'notification-email')
+
+jest.mock('@open-mercato/shared/lib/email/send', () => ({
+  sendEmail: (...args: unknown[]) => sendEmail(...args),
+}))
+
+jest.mock('../lib/deliveryStrategies', () => ({
+  getNotificationDeliveryStrategies: (...args: unknown[]) => getNotificationDeliveryStrategies(...args),
+}))
+
+jest.mock('../lib/deliveryConfig', () => ({
+  DEFAULT_NOTIFICATION_DELIVERY_CONFIG: {
+    panelPath: '/backend/notifications',
+    strategies: {
+      database: { enabled: true },
+      email: { enabled: true },
+      custom: {},
+    },
+  },
+  resolveNotificationDeliveryConfig: (...args: unknown[]) => resolveNotificationDeliveryConfig(...args),
+  resolveNotificationPanelUrl: (...args: unknown[]) => resolveNotificationPanelUrl(...args),
+}))
+
+jest.mock('@open-mercato/shared/lib/i18n/server', () => ({
+  loadDictionary: jest.fn().mockResolvedValue({}),
+}))
+
+jest.mock('@open-mercato/shared/lib/i18n/translate', () => ({
+  createFallbackTranslator: () => (key: string, fallback?: string) => fallback ?? key,
+}))
+
+jest.mock('@open-mercato/shared/lib/encryption/find', () => ({
+  findOneWithDecryption: (...args: unknown[]) => findOneWithDecryption(...args),
+}))
+
+jest.mock('../emails/NotificationEmail', () => ({
+  __esModule: true,
+  default: (...args: unknown[]) => NotificationEmail(...args),
+}))
+
+describe('deliver notification subscriber', () => {
+  const notification: Notification = {
+    id: '32e22a6e-7aa9-4f3b-8a7b-42c2d1223a5f',
+    recipientUserId: '3eae68bb-1e4c-4b21-85c7-b8f5b2c22b01',
+    tenantId: 'c33b6f78-8c4b-4ef4-9c54-2b64b5f5d0d0',
+    organizationId: null,
+    type: 'system',
+    title: 'New notification',
+    body: 'Check details',
+    titleKey: null,
+    bodyKey: null,
+    titleVariables: null,
+    bodyVariables: null,
+    icon: null,
+    severity: 'info',
+    actionData: {
+      actions: [{ id: 'action-1', label: 'Review' }],
+      primaryActionId: 'action-1',
+    },
+    sourceModule: null,
+    sourceEntityType: null,
+    sourceEntityId: null,
+    linkHref: null,
+    groupKey: null,
+    status: 'unread',
+    readAt: null,
+    actionedAt: null,
+    dismissedAt: null,
+    createdAt: new Date(),
+    updatedAt: new Date(),
+    expiresAt: null,
+    actionTaken: null,
+    actionResult: null,
+  } as Notification
+
+  const baseConfig: NotificationDeliveryConfig = {
+    appUrl: 'https://app.example.com',
+    panelPath: '/backend/notifications',
+    strategies: {
+      database: { enabled: true },
+      email: {
+        enabled: true,
+        from: 'notifications@example.com',
+        replyTo: 'reply@example.com',
+        subjectPrefix: '[OM]',
+      },
+      custom: {},
+    },
+  }
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  it('sends email notifications when enabled', async () => {
+    resolveNotificationDeliveryConfig.mockResolvedValue(baseConfig)
+    resolveNotificationPanelUrl.mockReturnValue('https://app.example.com/backend/notifications')
+    getNotificationDeliveryStrategies.mockReturnValue([])
+    findOneWithDecryption.mockResolvedValue({ email: 'user@example.com', name: 'User' })
+
+    const em = {
+      findOne: jest.fn().mockResolvedValue(notification),
+    }
+
+    const { default: handle } = await import('../subscribers/deliver-notification')
+
+    await handle(
+      {
+        notificationId: notification.id,
+        recipientUserId: notification.recipientUserId,
+        tenantId: notification.tenantId,
+        organizationId: null,
+      },
+      {
+        resolve: (name: string) => {
+          if (name === 'em') return em
+          throw new Error(`Missing dependency: ${name}`)
+        },
+      }
+    )
+
+    expect(NotificationEmail).toHaveBeenCalledWith(
+      expect.objectContaining({
+        title: notification.title,
+        panelUrl: `https://app.example.com/backend/notifications?notificationId=${notification.id}`,
+      })
+    )
+    expect(sendEmail).toHaveBeenCalledWith(
+      expect.objectContaining({
+        to: 'user@example.com',
+        from: baseConfig.strategies.email.from,
+        replyTo: baseConfig.strategies.email.replyTo,
+        subject: `${baseConfig.strategies.email.subjectPrefix} ${notification.title}`,
+      })
+    )
+  })
+
+  it('executes enabled custom delivery strategies', async () => {
+    const customStrategy: NotificationDeliveryStrategy = {
+      id: 'webhook',
+      deliver: jest.fn(),
+    }
+    resolveNotificationDeliveryConfig.mockResolvedValue({
+      ...baseConfig,
+      strategies: {
+        ...baseConfig.strategies,
+        email: { enabled: false },
+        custom: {
+          webhook: { enabled: true, config: { url: 'https://hooks.example.com' } },
+        },
+      },
+    })
+    resolveNotificationPanelUrl.mockReturnValue('/backend/notifications')
+    getNotificationDeliveryStrategies.mockReturnValue([customStrategy])
+    findOneWithDecryption.mockResolvedValue({ email: 'user@example.com', name: 'User' })
+
+    const em = {
+      findOne: jest.fn().mockResolvedValue(notification),
+    }
+
+    const { default: handle } = await import('../subscribers/deliver-notification')
+
+    await handle(
+      {
+        notificationId: notification.id,
+        recipientUserId: notification.recipientUserId,
+        tenantId: notification.tenantId,
+        organizationId: null,
+      },
+      {
+        resolve: (name: string) => {
+          if (name === 'em') return em
+          throw new Error(`Missing dependency: ${name}`)
+        },
+      }
+    )
+
+    expect(customStrategy.deliver).toHaveBeenCalledWith(
+      expect.objectContaining({
+        config: { enabled: true, config: { url: 'https://hooks.example.com' } },
+        panelLink: `/backend/notifications?notificationId=${notification.id}`,
+      })
+    )
+    expect(sendEmail).not.toHaveBeenCalled()
+  })
+})

package/src/modules/notifications/__tests__/deliveryStrategies.test.ts

@@ -0,0 +1,19 @@
+import { type NotificationDeliveryStrategy } from '../lib/deliveryStrategies'
+
+describe('notification delivery strategies', () => {
+  it('orders strategies by priority', async () => {
+    jest.resetModules()
+    const { registerNotificationDeliveryStrategy, getNotificationDeliveryStrategies } = await import('../lib/deliveryStrategies')
+
+    const first: NotificationDeliveryStrategy = { id: 'first', deliver: jest.fn() }
+    const second: NotificationDeliveryStrategy = { id: 'second', deliver: jest.fn() }
+    const third: NotificationDeliveryStrategy = { id: 'third', deliver: jest.fn() }
+
+    registerNotificationDeliveryStrategy(first, { priority: 1 })
+    registerNotificationDeliveryStrategy(second, { priority: 10 })
+    registerNotificationDeliveryStrategy(third, { priority: 5 })
+
+    const ids = getNotificationDeliveryStrategies().map((strategy) => strategy.id)
+    expect(ids).toEqual(['second', 'third', 'first'])
+  })
+})

package/src/modules/notifications/__tests__/notificationService.test.ts

@@ -0,0 +1,208 @@
+import { createNotificationService } from '../lib/notificationService'
+import { NOTIFICATION_EVENTS } from '../lib/events'
+import type { Notification } from '../data/entities'
+import { getRecipientUserIdsForFeature } from '../lib/notificationRecipients'
+
+jest.mock('../lib/notificationRecipients', () => ({
+  getRecipientUserIdsForRole: jest.fn(),
+  getRecipientUserIdsForFeature: jest.fn(),
+}))
+
+const baseNotificationInput = {
+  type: 'system',
+  title: 'Hello',
+  recipientUserId: '2d4a4c33-9c4b-4e39-8e15-0a3cd9a7f432',
+} as const
+
+const baseCtx = {
+  tenantId: '7f4c85ef-f8f7-4e53-9df1-42e95bd8d48e',
+  organizationId: null,
+  userId: '2d4a4c33-9c4b-4e39-8e15-0a3cd9a7f432',
+}
+
+const buildEm = () => {
+  const em = {
+    fork: jest.fn(),
+    create: jest.fn(),
+    persistAndFlush: jest.fn(),
+    flush: jest.fn(),
+    findOneOrFail: jest.fn(),
+    count: jest.fn(),
+    find: jest.fn(),
+    getConnection: jest.fn(),
+  }
+  em.fork.mockReturnValue(em)
+  em.getConnection.mockReturnValue({
+    getKnex: () => ({}),
+  })
+  return em
+}
+
+describe('notification service', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  it('creates a notification and emits event', async () => {
+    const em = buildEm()
+    const eventBus = { emit: jest.fn().mockResolvedValue(undefined) }
+
+    em.create.mockImplementation((_entity, data: Notification) => ({
+      id: 'note-1',
+      ...data,
+    }))
+
+    const service = createNotificationService({ em, eventBus })
+
+    const notification = await service.create(baseNotificationInput, baseCtx)
+
+    expect(notification.id).toBe('note-1')
+    expect(em.persistAndFlush).toHaveBeenCalledWith(notification)
+    expect(eventBus.emit).toHaveBeenCalledWith(
+      NOTIFICATION_EVENTS.CREATED,
+      expect.objectContaining({
+        notificationId: notification.id,
+        recipientUserId: baseNotificationInput.recipientUserId,
+        tenantId: baseCtx.tenantId,
+      })
+    )
+  })
+
+  it('creates batch notifications and emits events for each', async () => {
+    const em = buildEm()
+    const eventBus = { emit: jest.fn().mockResolvedValue(undefined) }
+
+    em.create.mockImplementation((_entity, data: Notification) => ({
+      id: `note-${data.recipientUserId}`,
+      ...data,
+    }))
+
+    const service = createNotificationService({ em, eventBus })
+
+    const notifications = await service.createBatch(
+      {
+        type: 'system',
+        title: 'Hello',
+        recipientUserIds: ['e2c9ac54-ecdb-4d79-8d73-8328ca0f16f0', 'e2d9e79c-3f2f-4b8c-9455-6c19b671dc5c'],
+      },
+      baseCtx
+    )
+
+    expect(notifications).toHaveLength(2)
+    expect(em.persistAndFlush).toHaveBeenCalledWith(notifications)
+    expect(eventBus.emit).toHaveBeenCalledTimes(2)
+  })
+
+  it('returns empty list when no recipients match feature', async () => {
+    const em = buildEm()
+    const eventBus = { emit: jest.fn().mockResolvedValue(undefined) }
+    const service = createNotificationService({ em, eventBus })
+
+    ;(getRecipientUserIdsForFeature as jest.Mock).mockResolvedValue([])
+
+    const result = await service.createForFeature(
+      {
+        type: 'system',
+        title: 'Hello',
+        requiredFeature: 'notifications.view',
+      },
+      baseCtx
+    )
+
+    expect(result).toEqual([])
+    expect(em.persistAndFlush).not.toHaveBeenCalled()
+    expect(eventBus.emit).not.toHaveBeenCalled()
+  })
+
+  it('marks a notification as read and emits event', async () => {
+    const em = buildEm()
+    const eventBus = { emit: jest.fn().mockResolvedValue(undefined) }
+    const service = createNotificationService({ em, eventBus })
+
+    const notification: Notification = {
+      id: 'note-2',
+      recipientUserId: baseCtx.userId ?? null,
+      tenantId: baseCtx.tenantId,
+      status: 'unread',
+      readAt: null,
+    } as Notification
+
+    em.findOneOrFail.mockResolvedValue(notification)
+
+    const result = await service.markAsRead(notification.id, baseCtx)
+
+    expect(result.status).toBe('read')
+    expect(result.readAt).toBeInstanceOf(Date)
+    expect(em.flush).toHaveBeenCalled()
+    expect(eventBus.emit).toHaveBeenCalledWith(
+      NOTIFICATION_EVENTS.READ,
+      expect.objectContaining({
+        notificationId: notification.id,
+        userId: baseCtx.userId,
+        tenantId: baseCtx.tenantId,
+      })
+    )
+  })
+
+  it('executes notification action via command bus', async () => {
+    const em = buildEm()
+    const eventBus = { emit: jest.fn().mockResolvedValue(undefined) }
+    const commandBus = { execute: jest.fn().mockResolvedValue({ result: { ok: true } }) }
+    const container = { resolve: jest.fn() }
+    const service = createNotificationService({ em, eventBus, commandBus, container })
+
+    const notification: Notification = {
+      id: 'note-3',
+      recipientUserId: baseCtx.userId ?? null,
+      tenantId: baseCtx.tenantId,
+      status: 'unread',
+      readAt: null,
+      sourceEntityId: '1f9d8d1c-319f-48d4-b803-77665b6b2510',
+      actionData: {
+        actions: [
+          {
+            id: 'approve',
+            label: 'Approve',
+            commandId: 'sales.approve',
+          },
+        ],
+        primaryActionId: 'approve',
+      },
+    } as Notification
+
+    em.findOneOrFail.mockResolvedValue(notification)
+
+    const result = await service.executeAction(
+      notification.id,
+      { actionId: 'approve', payload: { note: 'ok' } },
+      baseCtx
+    )
+
+    expect(commandBus.execute).toHaveBeenCalledWith(
+      'sales.approve',
+      expect.objectContaining({
+        input: expect.objectContaining({
+          id: notification.sourceEntityId,
+          note: 'ok',
+        }),
+        metadata: expect.objectContaining({
+          tenantId: baseCtx.tenantId,
+          organizationId: baseCtx.organizationId,
+          resourceKind: 'notifications',
+        }),
+      })
+    )
+    expect(result.result).toEqual({ ok: true })
+    expect(notification.status).toBe('actioned')
+    expect(notification.actionTaken).toBe('approve')
+    expect(eventBus.emit).toHaveBeenCalledWith(
+      NOTIFICATION_EVENTS.ACTIONED,
+      expect.objectContaining({
+        notificationId: notification.id,
+        actionId: 'approve',
+        userId: baseCtx.userId,
+        tenantId: baseCtx.tenantId,
+      })
+    )
+  })
+})

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

@@ -92,12 +92,17 @@ const notificationDeliveryEmailSchema = notificationDeliveryStrategySchema.exten
   subjectPrefix: z.string().trim().min(1).optional(),
 })
 
+const notificationDeliveryCustomSchema = notificationDeliveryStrategySchema.extend({
+  config: z.unknown().optional(),
+})
+
 export const notificationDeliveryConfigSchema = z.object({
   appUrl: z.string().url().optional(),
   panelPath: safeRelativeHrefSchema.optional(),
   strategies: z.object({
     database: notificationDeliveryStrategySchema.optional(),
     email: notificationDeliveryEmailSchema.optional(),
+    custom: z.record(z.string(), notificationDeliveryCustomSchema).optional(),
   }).optional(),
 })
 

package/src/modules/notifications/frontend/NotificationSettingsPageClient.tsx

@@ -17,6 +17,7 @@ type NotificationDeliveryConfig = {
   strategies: {
     database: { enabled: boolean }
     email: { enabled: boolean; from?: string; replyTo?: string; subjectPrefix?: string }
+    custom?: Record<string, { enabled?: boolean; config?: unknown }>
   }
 }
 
@@ -30,6 +31,7 @@ const emptySettings: NotificationDeliveryConfig = {
   strategies: {
     database: { enabled: true },
     email: { enabled: true },
+    custom: {},
   },
 }
 

package/src/modules/notifications/lib/deliveryConfig.ts

@@ -8,6 +8,11 @@ export type NotificationDeliveryStrategyState = {
   enabled: boolean
 }
 
+export type NotificationCustomDeliveryConfig = {
+  enabled?: boolean
+  config?: unknown
+}
+
 export type NotificationEmailDeliveryConfig = NotificationDeliveryStrategyState & {
   from?: string
   replyTo?: string
@@ -20,6 +25,7 @@ export type NotificationDeliveryConfig = {
   strategies: {
     database: NotificationDeliveryStrategyState
     email: NotificationEmailDeliveryConfig
+    custom?: Record<string, NotificationCustomDeliveryConfig>
   }
 }
 
@@ -65,6 +71,7 @@ export const DEFAULT_NOTIFICATION_DELIVERY_CONFIG: NotificationDeliveryConfig =
         replyTo: env.emailReplyTo,
         subjectPrefix: env.emailSubjectPrefix,
       },
+      custom: {},
     },
   }
 })()
@@ -91,6 +98,7 @@ const normalizeDeliveryConfig = (input?: unknown | null): NotificationDeliveryCo
         replyTo: strategies.email?.replyTo,
         subjectPrefix: strategies.email?.subjectPrefix,
       },
+      custom: strategies.custom ?? {},
     },
   }
 }

package/src/modules/notifications/lib/deliveryStrategies.ts

@@ -0,0 +1,50 @@
+import type { Notification } from '../data/entities'
+import type { NotificationDeliveryConfig } from './deliveryConfig'
+
+export type NotificationDeliveryStrategyConfig = {
+  enabled?: boolean
+  config?: unknown
+}
+
+export type NotificationDeliveryRecipient = {
+  email?: string | null
+  name?: string | null
+}
+
+export type NotificationDeliveryContext = {
+  notification: Notification
+  recipient: NotificationDeliveryRecipient
+  title: string
+  body: string | null
+  panelUrl: string | null
+  panelLink: string | null
+  actionLinks: Array<{ id: string; label: string; href: string }>
+  deliveryConfig: NotificationDeliveryConfig
+  config: NotificationDeliveryStrategyConfig
+  resolve: <T = unknown>(name: string) => T
+  t: (key: string, fallback?: string, variables?: Record<string, string>) => string
+}
+
+export type NotificationDeliveryStrategy = {
+  id: string
+  label?: string
+  defaultEnabled?: boolean
+  deliver: (ctx: NotificationDeliveryContext) => Promise<void> | void
+}
+
+type RegisteredStrategy = NotificationDeliveryStrategy & { priority: number }
+
+const registry: RegisteredStrategy[] = []
+
+export function registerNotificationDeliveryStrategy(
+  strategy: NotificationDeliveryStrategy,
+  options?: { priority?: number }
+): void {
+  const priority = options?.priority ?? 0
+  registry.push({ ...strategy, priority })
+  registry.sort((a, b) => b.priority - a.priority)
+}
+
+export function getNotificationDeliveryStrategies(): NotificationDeliveryStrategy[] {
+  return registry
+}