@open-mercato/core 0.4.2-canary-f821f89ef6 → 0.4.2-canary-3b5064ce72

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/acl.ts

@@ -0,0 +1,7 @@
+export const features = [
+  { id: 'notifications.view', title: 'View own notifications', module: 'notifications' },
+  { id: 'notifications.create', title: 'Create notifications for others', module: 'notifications' },
+  { id: 'notifications.manage', title: 'Manage all notifications', module: 'notifications' },
+]
+
+export default features

package/src/modules/notifications/api/[id]/action/route.ts

@@ -0,0 +1,75 @@
+import { executeActionSchema } from '../../../data/validators'
+import { actionResultResponseSchema, errorResponseSchema } from '../../openapi'
+import { resolveNotificationContext } from '../../../lib/routeHelpers'
+import { resolveTranslations } from '@open-mercato/shared/lib/i18n/server'
+
+export const metadata = {
+  POST: { requireAuth: true },
+}
+
+export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  const { service, scope } = await resolveNotificationContext(req)
+
+  const body = await req.json().catch(() => ({}))
+  const input = executeActionSchema.parse(body)
+
+  try {
+    const { notification, result } = await service.executeAction(id, input, scope)
+
+    const action = notification.actionData?.actions?.find((a) => a.id === input.actionId)
+    const href = action?.href?.replace('{sourceEntityId}', notification.sourceEntityId ?? '')
+
+    return Response.json({
+      ok: true,
+      result,
+      href,
+    })
+  } catch (error) {
+    const { t } = await resolveTranslations()
+    const fallback = t('notifications.error.action', 'Failed to execute action')
+    const message = error instanceof Error && error.message ? error.message : fallback
+    return Response.json({ error: message }, { status: 400 })
+  }
+}
+
+export const openApi = {
+  POST: {
+    summary: 'Execute notification action',
+    tags: ['Notifications'],
+    parameters: [
+      {
+        name: 'id',
+        in: 'path',
+        required: true,
+        schema: { type: 'string', format: 'uuid' },
+      },
+    ],
+    requestBody: {
+      required: true,
+      content: {
+        'application/json': {
+          schema: executeActionSchema,
+        },
+      },
+    },
+    responses: {
+      200: {
+        description: 'Action executed successfully',
+        content: {
+          'application/json': {
+            schema: actionResultResponseSchema,
+          },
+        },
+      },
+      400: {
+        description: 'Action not found or failed',
+        content: {
+          'application/json': {
+            schema: errorResponseSchema,
+          },
+        },
+      },
+    },
+  },
+}

package/src/modules/notifications/api/[id]/dismiss/route.ts

@@ -0,0 +1,12 @@
+import { createSingleNotificationActionRoute, createSingleNotificationActionOpenApi } from '../../../lib/routeHelpers'
+
+export const metadata = {
+  PUT: { requireAuth: true },
+}
+
+export const PUT = createSingleNotificationActionRoute('dismiss')
+
+export const openApi = createSingleNotificationActionOpenApi(
+  'Dismiss notification',
+  'Notification dismissed'
+)

package/src/modules/notifications/api/[id]/read/route.ts

@@ -0,0 +1,12 @@
+import { createSingleNotificationActionRoute, createSingleNotificationActionOpenApi } from '../../../lib/routeHelpers'
+
+export const metadata = {
+  PUT: { requireAuth: true },
+}
+
+export const PUT = createSingleNotificationActionRoute('markAsRead')
+
+export const openApi = createSingleNotificationActionOpenApi(
+  'Mark notification as read',
+  'Notification marked as read'
+)

package/src/modules/notifications/api/[id]/restore/route.ts

@@ -0,0 +1,53 @@
+import { z } from 'zod'
+import { restoreNotificationSchema } from '../../../data/validators'
+import { resolveNotificationContext } from '../../../lib/routeHelpers'
+
+export const metadata = {
+  PUT: { requireAuth: true },
+}
+
+export async function PUT(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  const { service, scope } = await resolveNotificationContext(req)
+
+  const body = await req.json().catch(() => ({}))
+  const input = restoreNotificationSchema.parse(body)
+
+  await service.restoreDismissed(id, input.status, scope)
+
+  return Response.json({ ok: true })
+}
+
+export const openApi = {
+  PUT: {
+    summary: 'Restore dismissed notification',
+    description: 'Undo a dismissal and restore a notification to read or unread.',
+    tags: ['Notifications'],
+    parameters: [
+      {
+        name: 'id',
+        in: 'path',
+        required: true,
+        schema: { type: 'string', format: 'uuid' },
+      },
+    ],
+    requestBody: {
+      required: false,
+      content: {
+        'application/json': {
+          schema: restoreNotificationSchema,
+        },
+      },
+    },
+    responses: {
+      200: {
+        description: 'Notification restored',
+        content: {
+          'application/json': {
+            schema: z.object({ ok: z.boolean() }),
+          },
+        },
+      },
+    },
+  },
+}

package/src/modules/notifications/api/batch/route.ts

@@ -0,0 +1,14 @@
+import { createBatchNotificationSchema } from '../../data/validators'
+import { createBulkNotificationRoute, createBulkNotificationOpenApi } from '../../lib/routeHelpers'
+
+export const metadata = {
+  POST: { requireAuth: true, requireFeatures: ['notifications.create'] },
+}
+
+export const POST = createBulkNotificationRoute(createBatchNotificationSchema, 'createBatch')
+
+export const openApi = createBulkNotificationOpenApi(
+  createBatchNotificationSchema,
+  'Create batch notifications',
+  'Send the same notification to multiple users'
+)

package/src/modules/notifications/api/feature/route.ts

@@ -0,0 +1,14 @@
+import { createFeatureNotificationSchema } from '../../data/validators'
+import { createBulkNotificationRoute, createBulkNotificationOpenApi } from '../../lib/routeHelpers'
+
+export const metadata = {
+  POST: { requireAuth: true, requireFeatures: ['notifications.create'] },
+}
+
+export const POST = createBulkNotificationRoute(createFeatureNotificationSchema, 'createForFeature')
+
+export const openApi = createBulkNotificationOpenApi(
+  createFeatureNotificationSchema,
+  'Create notifications for all users with a specific feature/permission',
+  'Send the same notification to all users who have the specified feature permission (via role ACL or user ACL). Supports wildcard matching.'
+)

package/src/modules/notifications/api/mark-all-read/route.ts

@@ -0,0 +1,34 @@
+import { z } from 'zod'
+import { resolveNotificationContext } from '../../lib/routeHelpers'
+
+export const metadata = {
+  PUT: { requireAuth: true },
+}
+
+export async function PUT(req: Request) {
+  const { service, scope } = await resolveNotificationContext(req)
+
+  const count = await service.markAllAsRead(scope)
+
+  return Response.json({ ok: true, count })
+}
+
+export const openApi = {
+  PUT: {
+    summary: 'Mark all notifications as read',
+    tags: ['Notifications'],
+    responses: {
+      200: {
+        description: 'All notifications marked as read',
+        content: {
+          'application/json': {
+            schema: z.object({
+              ok: z.boolean(),
+              count: z.number(),
+            }),
+          },
+        },
+      },
+    },
+  },
+}