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

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

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

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

@@ -0,0 +1,92 @@
+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.',
+  },
+})

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

@@ -0,0 +1,157 @@
+import { NextResponse } from 'next/server'
+import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
+import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
+import { resolveTranslations } from '@open-mercato/shared/lib/i18n/server'
+import { notificationDeliveryConfigSchema } from '../../data/validators'
+import {
+  errorResponseSchema,
+  notificationSettingsResponseSchema,
+  notificationSettingsUpdateResponseSchema,
+} from '../openapi'
+import {
+  DEFAULT_NOTIFICATION_DELIVERY_CONFIG,
+  resolveNotificationDeliveryConfig,
+  saveNotificationDeliveryConfig,
+} from '../../lib/deliveryConfig'
+
+export const metadata = {
+  GET: { requireAuth: true, requireFeatures: ['notifications.manage'] },
+  POST: { requireAuth: true, requireFeatures: ['notifications.manage'] },
+}
+
+const unauthorized = async () => {
+  const { t } = await resolveTranslations()
+  return NextResponse.json({ error: t('api.errors.unauthorized', 'Unauthorized') }, { status: 401 })
+}
+
+export async function GET(req: Request) {
+  const auth = await getAuthFromRequest(req)
+  if (!auth?.sub) return await unauthorized()
+
+  const container = await createRequestContainer()
+  try {
+    const settings = await resolveNotificationDeliveryConfig(container, {
+      defaultValue: DEFAULT_NOTIFICATION_DELIVERY_CONFIG,
+    })
+    return NextResponse.json({ settings })
+  } finally {
+    const disposable = container as unknown as { dispose?: () => Promise<void> }
+    if (typeof disposable.dispose === 'function') {
+      await disposable.dispose()
+    }
+  }
+}
+
+export async function POST(req: Request) {
+  const { t } = await resolveTranslations()
+  const auth = await getAuthFromRequest(req)
+  if (!auth?.sub) return await unauthorized()
+
+  let body: unknown
+  try {
+    body = await req.json()
+  } catch {
+    return NextResponse.json(
+      { error: t('api.errors.invalidPayload', 'Invalid request body') },
+      { status: 400 }
+    )
+  }
+
+  const parsed = notificationDeliveryConfigSchema.safeParse(body)
+  if (!parsed.success) {
+    return NextResponse.json(
+      { error: t('notifications.delivery.settings.invalid', 'Invalid delivery settings') },
+      { status: 400 }
+    )
+  }
+
+  const container = await createRequestContainer()
+  try {
+    await saveNotificationDeliveryConfig(container, parsed.data)
+    const settings = await resolveNotificationDeliveryConfig(container, {
+      defaultValue: DEFAULT_NOTIFICATION_DELIVERY_CONFIG,
+    })
+    return NextResponse.json({ ok: true, settings })
+  } catch (error) {
+    return NextResponse.json(
+      { error: error instanceof Error ? error.message : t('api.errors.internal', 'Internal error') },
+      { status: 500 }
+    )
+  } finally {
+    const disposable = container as unknown as { dispose?: () => Promise<void> }
+    if (typeof disposable.dispose === 'function') {
+      await disposable.dispose()
+    }
+  }
+}
+
+export const openApi = {
+  GET: {
+    summary: 'Get notification delivery settings',
+    tags: ['Notifications'],
+    responses: {
+      200: {
+        description: 'Current delivery settings',
+        content: {
+          'application/json': {
+            schema: notificationSettingsResponseSchema,
+          },
+        },
+      },
+      401: {
+        description: 'Unauthorized',
+        content: {
+          'application/json': {
+            schema: errorResponseSchema,
+          },
+        },
+      },
+    },
+  },
+  POST: {
+    summary: 'Update notification delivery settings',
+    tags: ['Notifications'],
+    requestBody: {
+      required: true,
+      content: {
+        'application/json': {
+          schema: notificationDeliveryConfigSchema,
+        },
+      },
+    },
+    responses: {
+      200: {
+        description: 'Delivery settings updated',
+        content: {
+          'application/json': {
+            schema: notificationSettingsUpdateResponseSchema,
+          },
+        },
+      },
+      400: {
+        description: 'Invalid request body',
+        content: {
+          'application/json': {
+            schema: errorResponseSchema,
+          },
+        },
+      },
+      401: {
+        description: 'Unauthorized',
+        content: {
+          'application/json': {
+            schema: errorResponseSchema,
+          },
+        },
+      },
+      500: {
+        description: 'Internal error',
+        content: {
+          'application/json': {
+            schema: errorResponseSchema,
+          },
+        },
+      },
+    },
+  },
+}

package/src/modules/notifications/api/unread-count/route.ts

@@ -0,0 +1,38 @@
+import type { EntityManager } from '@mikro-orm/core'
+import { Notification } from '../../data/entities'
+import { unreadCountResponseSchema } from '../openapi'
+import { resolveNotificationContext } from '../../lib/routeHelpers'
+
+export const metadata = {
+  GET: { requireAuth: true },
+}
+
+export async function GET(req: Request) {
+  const { scope, ctx } = await resolveNotificationContext(req)
+  const em = ctx.container.resolve('em') as EntityManager
+
+  const count = await em.count(Notification, {
+    recipientUserId: scope.userId,
+    tenantId: scope.tenantId,
+    status: 'unread',
+  })
+
+  return Response.json({ unreadCount: count })
+}
+
+export const openApi = {
+  GET: {
+    summary: 'Get unread notification count',
+    tags: ['Notifications'],
+    responses: {
+      200: {
+        description: 'Unread count',
+        content: {
+          'application/json': {
+            schema: unreadCountResponseSchema,
+          },
+        },
+      },
+    },
+  },
+}

package/src/modules/notifications/backend/config/notifications/page.meta.ts

@@ -0,0 +1,22 @@
+import React from 'react'
+
+const bellIcon = React.createElement(
+  'svg',
+  { width: 16, height: 16, viewBox: '0 0 24 24', fill: 'none', stroke: 'currentColor', strokeWidth: 2, strokeLinecap: 'round', strokeLinejoin: 'round' },
+  React.createElement('path', { d: 'M18 8a6 6 0 0 0-12 0c0 7-3 9-3 9h18s-3-2-3-9' }),
+  React.createElement('path', { d: 'M13.73 21a2 2 0 0 1-3.46 0' }),
+)
+
+export const metadata = {
+  requireAuth: true,
+  requireFeatures: ['notifications.manage'],
+  pageTitle: 'Notification Delivery',
+  pageTitleKey: 'notifications.settings.pageTitle',
+  pageGroup: 'Configuration',
+  pageGroupKey: 'backend.nav.configuration',
+  pageOrder: 435,
+  icon: bellIcon,
+  breadcrumb: [
+    { label: 'Notification Delivery', labelKey: 'notifications.settings.pageTitle' },
+  ],
+} as const

package/src/modules/notifications/backend/config/notifications/page.tsx

@@ -0,0 +1,12 @@
+import { Page, PageBody } from '@open-mercato/ui/backend/Page'
+import { NotificationSettingsPageClient } from '../../../frontend/NotificationSettingsPageClient'
+
+export default async function NotificationSettingsPage() {
+  return (
+    <Page>
+      <PageBody>
+        <NotificationSettingsPageClient />
+      </PageBody>
+    </Page>
+  )
+}

package/src/modules/notifications/cli.ts

@@ -0,0 +1,18 @@
+import type { ModuleCli } from '@open-mercato/shared/modules/registry'
+import { createQueue } from '@open-mercato/queue'
+import type { CleanupExpiredJob } from './workers/create-notification.worker'
+
+const cleanupExpiredCommand: ModuleCli = {
+  command: 'cleanup-expired',
+  async run() {
+    const queue = createQueue('notifications', 'async')
+
+    await queue.enqueue({
+      type: 'cleanup-expired',
+    } satisfies CleanupExpiredJob)
+
+    console.log('✓ Cleanup job enqueued')
+  },
+}
+
+export default [cleanupExpiredCommand]

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

@@ -0,0 +1,99 @@
+import { Entity, PrimaryKey, Property, Index, OptionalProps } from '@mikro-orm/core'
+import type { NotificationActionData } from '@open-mercato/shared/modules/notifications/types'
+
+export type NotificationStatus = 'unread' | 'read' | 'actioned' | 'dismissed'
+export type NotificationSeverity = 'info' | 'warning' | 'success' | 'error'
+
+@Entity({ tableName: 'notifications' })
+@Index({ name: 'notifications_recipient_status_idx', properties: ['recipientUserId', 'status', 'createdAt'] })
+@Index({ name: 'notifications_source_idx', properties: ['sourceEntityType', 'sourceEntityId'] })
+@Index({ name: 'notifications_tenant_idx', properties: ['tenantId', 'organizationId'] })
+@Index({ name: 'notifications_expires_idx', properties: ['expiresAt'] })
+@Index({ name: 'notifications_group_idx', properties: ['groupKey', 'recipientUserId'] })
+export class Notification {
+  [OptionalProps]?: 'status' | 'severity' | 'createdAt'
+
+  @PrimaryKey({ type: 'uuid', defaultRaw: 'gen_random_uuid()' })
+  id!: string
+
+  @Property({ name: 'recipient_user_id', type: 'uuid' })
+  recipientUserId!: string
+
+  @Property({ name: 'type', type: 'text' })
+  type!: string
+
+  // i18n keys (preferred for i18n-first approach)
+  @Property({ name: 'title_key', type: 'text', nullable: true })
+  titleKey?: string | null
+
+  @Property({ name: 'body_key', type: 'text', nullable: true })
+  bodyKey?: string | null
+
+  // Template variables for i18n interpolation (stored as JSONB)
+  @Property({ name: 'title_variables', type: 'json', nullable: true })
+  titleVariables?: Record<string, string> | null
+
+  @Property({ name: 'body_variables', type: 'json', nullable: true })
+  bodyVariables?: Record<string, string> | null
+
+  // Fallback text (for backward compatibility or when keys are not available)
+  @Property({ name: 'title', type: 'text' })
+  title!: string
+
+  @Property({ name: 'body', type: 'text', nullable: true })
+  body?: string | null
+
+  @Property({ name: 'icon', type: 'text', nullable: true })
+  icon?: string | null
+
+  @Property({ name: 'severity', type: 'text', default: 'info' })
+  severity: NotificationSeverity = 'info'
+
+  @Property({ name: 'status', type: 'text', default: 'unread' })
+  status: NotificationStatus = 'unread'
+
+  @Property({ name: 'action_data', type: 'json', nullable: true })
+  actionData?: NotificationActionData | null
+
+  @Property({ name: 'action_result', type: 'json', nullable: true })
+  actionResult?: Record<string, unknown> | null
+
+  @Property({ name: 'action_taken', type: 'text', nullable: true })
+  actionTaken?: string | null
+
+  @Property({ name: 'source_module', type: 'text', nullable: true })
+  sourceModule?: string | null
+
+  @Property({ name: 'source_entity_type', type: 'text', nullable: true })
+  sourceEntityType?: string | null
+
+  @Property({ name: 'source_entity_id', type: 'uuid', nullable: true })
+  sourceEntityId?: string | null
+
+  @Property({ name: 'link_href', type: 'text', nullable: true })
+  linkHref?: string | null
+
+  @Property({ name: 'group_key', type: 'text', nullable: true })
+  groupKey?: string | null
+
+  @Property({ name: 'created_at', type: Date, onCreate: () => new Date() })
+  createdAt: Date = new Date()
+
+  @Property({ name: 'read_at', type: Date, nullable: true })
+  readAt?: Date | null
+
+  @Property({ name: 'actioned_at', type: Date, nullable: true })
+  actionedAt?: Date | null
+
+  @Property({ name: 'dismissed_at', type: Date, nullable: true })
+  dismissedAt?: Date | null
+
+  @Property({ name: 'expires_at', type: Date, nullable: true })
+  expiresAt?: Date | null
+
+  @Property({ name: 'tenant_id', type: 'uuid' })
+  tenantId!: string
+
+  @Property({ name: 'organization_id', type: 'uuid', nullable: true })
+  organizationId?: string | null
+}

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

@@ -0,0 +1,115 @@
+import { z } from 'zod'
+import { isSafeNotificationHref } from '../lib/safeHref'
+
+export const notificationStatusSchema = z.enum(['unread', 'read', 'actioned', 'dismissed'])
+export const notificationSeveritySchema = z.enum(['info', 'warning', 'success', 'error'])
+
+export const safeRelativeHrefSchema = z.string().min(1).refine(
+  (href) => isSafeNotificationHref(href),
+  { message: 'Href must be a same-origin relative path starting with /' }
+)
+
+export const notificationActionSchema = z.object({
+  id: z.string().min(1),
+  label: z.string().min(1),
+  labelKey: z.string().optional(),
+  variant: z.enum(['default', 'secondary', 'destructive', 'outline', 'ghost']).optional(),
+  icon: z.string().optional(),
+  commandId: z.string().optional(),
+  href: safeRelativeHrefSchema.optional(),
+  confirmRequired: z.boolean().optional(),
+  confirmMessage: z.string().optional(),
+})
+
+const baseNotificationFieldsSchema = z.object({
+  type: z.string().min(1).max(100),
+  titleKey: z.string().min(1).max(200).optional(),
+  bodyKey: z.string().min(1).max(200).optional(),
+  titleVariables: z.record(z.string(), z.string()).optional(),
+  bodyVariables: z.record(z.string(), z.string()).optional(),
+  title: z.string().min(1).max(500).optional(),
+  body: z.string().max(2000).optional(),
+  icon: z.string().max(100).optional(),
+  severity: notificationSeveritySchema.optional().default('info'),
+  actions: z.array(notificationActionSchema).optional(),
+  primaryActionId: z.string().optional(),
+  sourceModule: z.string().optional(),
+  sourceEntityType: z.string().optional(),
+  sourceEntityId: z.string().uuid().optional(),
+  linkHref: safeRelativeHrefSchema.optional(),
+  groupKey: z.string().optional(),
+  expiresAt: z.string().datetime().optional(),
+})
+
+const titleRequiredRefinement = {
+  refine: (data: { titleKey?: string; title?: string }) => data.titleKey || data.title,
+  message: 'Either titleKey or title must be provided',
+} as const
+
+export const createNotificationSchema = baseNotificationFieldsSchema
+  .extend({ recipientUserId: z.string().uuid() })
+  .refine(titleRequiredRefinement.refine, { message: titleRequiredRefinement.message })
+
+export const createBatchNotificationSchema = baseNotificationFieldsSchema
+  .extend({ recipientUserIds: z.array(z.string().uuid()).min(1).max(1000) })
+  .refine(titleRequiredRefinement.refine, { message: titleRequiredRefinement.message })
+
+export const createRoleNotificationSchema = baseNotificationFieldsSchema
+  .extend({ roleId: z.string().uuid() })
+  .refine(titleRequiredRefinement.refine, { message: titleRequiredRefinement.message })
+
+export const createFeatureNotificationSchema = baseNotificationFieldsSchema
+  .extend({ requiredFeature: z.string().min(1).max(100) })
+  .refine(titleRequiredRefinement.refine, { message: titleRequiredRefinement.message })
+
+export const listNotificationsSchema = z.object({
+  status: z.union([notificationStatusSchema, z.array(notificationStatusSchema)]).optional(),
+  type: z.string().optional(),
+  severity: notificationSeveritySchema.optional(),
+  sourceEntityType: z.string().optional(),
+  sourceEntityId: z.string().uuid().optional(),
+  since: z.string().datetime().optional(),
+  page: z.coerce.number().int().min(1).optional().default(1),
+  pageSize: z.coerce.number().int().min(1).max(100).optional().default(20),
+})
+
+export const executeActionSchema = z.object({
+  actionId: z.string().min(1),
+  payload: z.record(z.string(), z.unknown()).optional(),
+})
+
+export const restoreNotificationSchema = z.object({
+  status: z.enum(['read', 'unread']).optional(),
+})
+
+const notificationDeliveryStrategySchema = z.object({
+  enabled: z.boolean().optional(),
+})
+
+const notificationDeliveryEmailSchema = notificationDeliveryStrategySchema.extend({
+  from: z.string().trim().min(1).optional(),
+  replyTo: z.string().trim().min(1).optional(),
+  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(),
+})
+
+export type CreateNotificationInput = z.infer<typeof createNotificationSchema>
+export type CreateBatchNotificationInput = z.infer<typeof createBatchNotificationSchema>
+export type CreateRoleNotificationInput = z.infer<typeof createRoleNotificationSchema>
+export type CreateFeatureNotificationInput = z.infer<typeof createFeatureNotificationSchema>
+export type ListNotificationsInput = z.infer<typeof listNotificationsSchema>
+export type ExecuteActionInput = z.infer<typeof executeActionSchema>
+export type NotificationDeliveryConfigInput = z.infer<typeof notificationDeliveryConfigSchema>

package/src/modules/notifications/di.ts

@@ -0,0 +1,11 @@
+import type { AppContainer } from '@open-mercato/shared/lib/di/container'
+import { asFunction } from 'awilix'
+import { createNotificationService } from './lib/notificationService'
+
+export function register(container: AppContainer): void {
+  container.register({
+    notificationService: asFunction(({ em, eventBus, commandBus }) =>
+      createNotificationService({ em, eventBus, commandBus })
+    ).scoped(),
+  })
+}