@open-mercato/core 0.4.2-canary-3b5064ce72 → 0.4.2-canary-15e78de280

package/src/modules/dashboards/lib/role-widgets.ts

@@ -1,80 +0,0 @@
-import type { EntityManager } from '@mikro-orm/postgresql'
-import { Role } from '@open-mercato/core/modules/auth/data/entities'
-import { DashboardRoleWidgets } from '../data/entities'
-import { loadAllWidgets } from './widgets'
-
-type RoleWidgetScope = {
-  tenantId: string
-  organizationId?: string | null
-  roleNames: string[]
-  widgetIds: string[]
-}
-
-async function findRoleByName(
-  em: EntityManager,
-  roleName: string,
-  tenantId: string,
-): Promise<Role | null> {
-  const tenantRole = await em.findOne(Role, { name: roleName, tenantId })
-  if (tenantRole) return tenantRole
-  return em.findOne(Role, { name: roleName, tenantId: null })
-}
-
-export async function resolveAnalyticsWidgetIds(): Promise<string[]> {
-  const widgets = await loadAllWidgets()
-  return widgets
-    .filter((widget) => widget.metadata.category === 'analytics' || widget.metadata.id.startsWith('dashboards.analytics.'))
-    .map((widget) => widget.metadata.id)
-}
-
-export async function appendWidgetsToRoles(
-  em: EntityManager,
-  { tenantId, organizationId = null, roleNames, widgetIds }: RoleWidgetScope,
-): Promise<boolean> {
-  const trimmedTenantId = tenantId.trim()
-  const widgets = await loadAllWidgets()
-  const validWidgetIds = new Set(widgets.map((widget) => widget.metadata.id))
-  const resolvedWidgetIds = widgetIds.filter((id) => validWidgetIds.has(id))
-  if (!resolvedWidgetIds.length) return false
-
-  let updated = false
-  await em.transactional(async (tem) => {
-    for (const roleName of roleNames) {
-      const role = await findRoleByName(tem, roleName, trimmedTenantId)
-      if (!role) continue
-
-      const record = await tem.findOne(DashboardRoleWidgets, {
-        roleId: String(role.id),
-        tenantId: trimmedTenantId,
-        organizationId,
-        deletedAt: null,
-      })
-      const roleRecord = record ?? (organizationId
-        ? await tem.findOne(DashboardRoleWidgets, {
-          roleId: String(role.id),
-          tenantId: trimmedTenantId,
-          organizationId: null,
-          deletedAt: null,
-        })
-        : null)
-      if (!roleRecord) continue
-
-      const current = Array.isArray(roleRecord.widgetIdsJson) ? roleRecord.widgetIdsJson : []
-      const next = [...current]
-      const existing = new Set(current)
-      for (const widgetId of resolvedWidgetIds) {
-        if (existing.has(widgetId)) continue
-        existing.add(widgetId)
-        next.push(widgetId)
-      }
-
-      if (next.length === current.length) continue
-      roleRecord.widgetIdsJson = next
-      roleRecord.updatedAt = new Date()
-      tem.persist(roleRecord)
-      updated = true
-    }
-  })
-
-  return updated
-}

package/src/modules/directory/api/get/tenants/lookup.ts

@@ -1,75 +0,0 @@
-import { NextResponse } from 'next/server'
-import { z } from 'zod'
-import type { EntityManager } from '@mikro-orm/postgresql'
-import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
-import { Tenant } from '@open-mercato/core/modules/directory/data/entities'
-import type { OpenApiMethodDoc, OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
-
-export const metadata = {
-  GET: {
-    requireAuth: false,
-  },
-}
-
-const tenantLookupQuerySchema = z.object({
-  tenantId: z.string().uuid(),
-})
-
-export async function GET(req: Request) {
-  const url = new URL(req.url)
-  const tenantId = url.searchParams.get('tenantId') || url.searchParams.get('tenant') || ''
-  const parsed = tenantLookupQuerySchema.safeParse({ tenantId })
-  if (!parsed.success) {
-    return NextResponse.json({ ok: false, error: 'Invalid tenant id.' }, { status: 400 })
-  }
-
-  const container = await createRequestContainer()
-  const em = (container.resolve('em') as EntityManager)
-  const tenant = await em.findOne(Tenant, { id: parsed.data.tenantId, deletedAt: null })
-  if (!tenant) {
-    return NextResponse.json({ ok: false, error: 'Tenant not found.' }, { status: 404 })
-  }
-  return NextResponse.json({
-    ok: true,
-    tenant: { id: String(tenant.id), name: tenant.name },
-  })
-}
-
-const lookupTag = 'Directory'
-
-const tenantLookupSuccessSchema = z.object({
-  ok: z.literal(true),
-  tenant: z.object({
-    id: z.string().uuid(),
-    name: z.string(),
-  }),
-})
-
-const tenantLookupErrorSchema = z.object({
-  ok: z.literal(false),
-  error: z.string(),
-})
-
-const tenantLookupDoc: OpenApiMethodDoc = {
-  summary: 'Public tenant lookup',
-  description: 'Resolves tenant metadata for login/activation flows.',
-  tags: [lookupTag],
-  query: tenantLookupQuerySchema,
-  responses: [
-    { status: 200, description: 'Tenant resolved.', schema: tenantLookupSuccessSchema },
-  ],
-  errors: [
-    { status: 400, description: 'Invalid tenant id', schema: tenantLookupErrorSchema },
-    { status: 404, description: 'Tenant not found', schema: tenantLookupErrorSchema },
-  ],
-}
-
-export const openApi: OpenApiRouteDoc = {
-  tag: lookupTag,
-  summary: 'Public tenant lookup',
-  methods: {
-    GET: tenantLookupDoc,
-  },
-}
-
-export default GET

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

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

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

@@ -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'
-)