@open-mercato/core 0.4.2-canary-ab36fbd8f2 → 0.4.2-canary-da2b080494

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

@@ -1,208 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,75 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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(),
-            }),
-          },
-        },
-      },
-    },
-  },
-}

package/src/modules/notifications/api/openapi.ts

@@ -1,76 +0,0 @@
-import { z } from 'zod'
-import { createCrudOpenApiFactory, createPagedListResponseSchema } from '@open-mercato/shared/lib/openapi/crud'
-import {
-  listNotificationsSchema,
-  createNotificationSchema,
-  executeActionSchema,
-  notificationDeliveryConfigSchema,
-} from '../data/validators'
-
-export const buildNotificationsCrudOpenApi = createCrudOpenApiFactory({
-  defaultTag: 'Notifications',
-})
-
-export const notificationItemSchema = z.object({
-  id: z.string().uuid(),
-  type: z.string(),
-  title: z.string(),
-  body: z.string().nullable().optional(),
-  titleKey: z.string().nullable().optional(),
-  bodyKey: z.string().nullable().optional(),
-  titleVariables: z.record(z.string(), z.string()).nullable().optional(),
-  bodyVariables: z.record(z.string(), z.string()).nullable().optional(),
-  icon: z.string().nullable().optional(),
-  severity: z.string(),
-  status: z.string(),
-  actions: z.array(z.object({
-    id: z.string(),
-    label: z.string(),
-    labelKey: z.string().optional(),
-    variant: z.string().optional(),
-    icon: z.string().optional(),
-  })),
-  primaryActionId: z.string().optional(),
-  sourceModule: z.string().nullable().optional(),
-  sourceEntityType: z.string().nullable().optional(),
-  sourceEntityId: z.string().uuid().nullable().optional(),
-  linkHref: z.string().nullable().optional(),
-  createdAt: z.string(),
-  readAt: z.string().nullable().optional(),
-  actionTaken: z.string().nullable().optional(),
-})
-
-export const okResponseSchema = z.object({
-  ok: z.boolean(),
-})
-
-export const errorResponseSchema = z.object({
-  error: z.string(),
-})
-
-export const unreadCountResponseSchema = z.object({
-  unreadCount: z.number(),
-})
-
-export const actionResultResponseSchema = z.object({
-  ok: z.boolean(),
-  result: z.unknown().optional(),
-  href: z.string().optional(),
-})
-
-export const notificationSettingsResponseSchema = z.object({
-  settings: notificationDeliveryConfigSchema,
-})
-
-export const notificationSettingsUpdateResponseSchema = z.object({
-  ok: z.boolean(),
-  settings: notificationDeliveryConfigSchema,
-})
-
-export {
-  createPagedListResponseSchema,
-  listNotificationsSchema,
-  createNotificationSchema,
-  executeActionSchema,
-  notificationDeliveryConfigSchema,
-}

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

@@ -1,14 +0,0 @@
-import { createRoleNotificationSchema } from '../../data/validators'
-import { createBulkNotificationRoute, createBulkNotificationOpenApi } from '../../lib/routeHelpers'
-
-export const metadata = {
-  POST: { requireAuth: true, requireFeatures: ['notifications.create'] },
-}
-
-export const POST = createBulkNotificationRoute(createRoleNotificationSchema, 'createForRole')
-
-export const openApi = createBulkNotificationOpenApi(
-  createRoleNotificationSchema,
-  'Create notifications for all users in a role',
-  'Send the same notification to all users who have the specified role within the organization'
-)

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

@@ -1,92 +0,0 @@
-import { z } from 'zod'
-import type { EntityManager } from '@mikro-orm/core'
-import { Notification } from '../data/entities'
-import { listNotificationsSchema, createNotificationSchema } from '../data/validators'
-import { toNotificationDto } from '../lib/notificationMapper'
-import { resolveNotificationContext } from '../lib/routeHelpers'
-import {
-  buildNotificationsCrudOpenApi,
-  createPagedListResponseSchema,
-  notificationItemSchema,
-} from './openapi'
-
-export const metadata = {
-  GET: { requireAuth: true },
-  POST: { requireAuth: true, requireFeatures: ['notifications.create'] },
-}
-
-export async function GET(req: Request) {
-  const { ctx, scope } = await resolveNotificationContext(req)
-  const em = ctx.container.resolve('em') as EntityManager
-
-  const url = new URL(req.url)
-  const queryParams = Object.fromEntries(url.searchParams.entries())
-  const input = listNotificationsSchema.parse(queryParams)
-
-  const filters: Record<string, unknown> = {
-    recipientUserId: scope.userId,
-    tenantId: scope.tenantId,
-  }
-
-  if (input.status) {
-    filters.status = Array.isArray(input.status) ? { $in: input.status } : input.status
-  } else {
-    filters.status = { $ne: 'dismissed' }
-  }
-  if (input.type) {
-    filters.type = input.type
-  }
-  if (input.severity) {
-    filters.severity = input.severity
-  }
-  if (input.sourceEntityType) {
-    filters.sourceEntityType = input.sourceEntityType
-  }
-  if (input.sourceEntityId) {
-    filters.sourceEntityId = input.sourceEntityId
-  }
-  if (input.since) {
-    filters.createdAt = { $gt: new Date(input.since) }
-  }
-
-  const [notifications, total] = await Promise.all([
-    em.find(Notification, filters, {
-      orderBy: { createdAt: 'desc' },
-      limit: input.pageSize,
-      offset: (input.page - 1) * input.pageSize,
-    }),
-    em.count(Notification, filters),
-  ])
-
-  const items = notifications.map(toNotificationDto)
-
-  return Response.json({
-    items,
-    total,
-    page: input.page,
-    pageSize: input.pageSize,
-    totalPages: Math.ceil(total / input.pageSize),
-  })
-}
-
-export async function POST(req: Request) {
-  const { service, scope } = await resolveNotificationContext(req)
-
-  const body = await req.json().catch(() => ({}))
-  const input = createNotificationSchema.parse(body)
-
-  const notification = await service.create(input, scope)
-
-  return Response.json({ id: notification.id }, { status: 201 })
-}
-
-export const openApi = buildNotificationsCrudOpenApi({
-  resourceName: 'Notification',
-  querySchema: listNotificationsSchema,
-  listResponseSchema: createPagedListResponseSchema(notificationItemSchema),
-  create: {
-    schema: createNotificationSchema,
-    responseSchema: z.object({ id: z.string().uuid() }),
-    description: 'Creates a notification for a user.',
-  },
-})