@open-mercato/core 0.4.2-canary-36ab8921da → 0.4.2-canary-07dbc98202

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,110 @@
+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(),
+})
+
+export const notificationDeliveryConfigSchema = z.object({
+  appUrl: z.string().url().optional(),
+  panelPath: safeRelativeHrefSchema.optional(),
+  strategies: z.object({
+    database: notificationDeliveryStrategySchema.optional(),
+    email: notificationDeliveryEmailSchema.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(),
+  })
+}

package/src/modules/notifications/emails/NotificationEmail.tsx

@@ -0,0 +1,98 @@
+import React from 'react'
+import { Html, Head, Preview, Body, Container, Heading, Text, Section, Button, Hr } from '@react-email/components'
+
+export type NotificationEmailAction = {
+  id: string
+  label: string
+  href: string
+}
+
+export type NotificationEmailCopy = {
+  preview: string
+  heading: string
+  bodyIntro: string
+  actionNotice: string
+  openCta: string
+  footer: string
+}
+
+type NotificationEmailProps = {
+  title: string
+  body?: string | null
+  actions: NotificationEmailAction[]
+  panelUrl: string
+  copy: NotificationEmailCopy
+}
+
+export function NotificationEmail({ title, body, actions, panelUrl, copy }: NotificationEmailProps) {
+  return (
+    <Html>
+      <Head />
+      <Preview>{copy.preview}</Preview>
+      <Body style={{ backgroundColor: '#f5f5f5', fontFamily: 'Arial, sans-serif', margin: 0, padding: 0 }}>
+        <Container style={{ maxWidth: 560, margin: '0 auto', padding: '24px' }}>
+          <Section style={{ backgroundColor: '#ffffff', padding: '24px', borderRadius: 12 }}>
+            <Heading as="h1" style={{ fontSize: '22px', margin: '0 0 8px', color: '#111827' }}>
+              {copy.heading}
+            </Heading>
+            <Text style={{ margin: '0 0 16px', color: '#4b5563' }}>{title}</Text>
+            {body && (
+              <Text style={{ margin: '0 0 16px', color: '#111827', fontSize: '15px' }}>
+                {body}
+              </Text>
+            )}
+            <Text style={{ margin: '0 0 16px', color: '#6b7280', fontSize: '13px' }}>
+              {copy.bodyIntro}
+            </Text>
+            {actions.length > 0 && (
+              <Section style={{ marginBottom: 16 }}>
+                {actions.map((action) => (
+                  <Button
+                    key={action.id}
+                    href={action.href}
+                    style={{
+                      backgroundColor: '#111827',
+                      color: '#ffffff',
+                      padding: '10px 16px',
+                      borderRadius: 8,
+                      textDecoration: 'none',
+                      display: 'inline-block',
+                      marginRight: 8,
+                      marginBottom: 8,
+                      fontSize: '13px',
+                    }}
+                  >
+                    {action.label}
+                  </Button>
+                ))}
+              </Section>
+            )}
+            <Text style={{ margin: '0 0 16px', color: '#6b7280', fontSize: '12px' }}>
+              {copy.actionNotice}
+            </Text>
+            <Button
+              href={panelUrl}
+              style={{
+                backgroundColor: '#2563eb',
+                color: '#ffffff',
+                padding: '12px 18px',
+                borderRadius: 8,
+                textDecoration: 'none',
+                display: 'inline-block',
+                fontSize: '14px',
+              }}
+            >
+              {copy.openCta}
+            </Button>
+            <Hr style={{ margin: '24px 0', borderColor: '#e5e7eb' }} />
+            <Text style={{ margin: 0, color: '#9ca3af', fontSize: '12px' }}>
+              {copy.footer}
+            </Text>
+          </Section>
+        </Container>
+      </Body>
+    </Html>
+  )
+}
+
+export default NotificationEmail

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

@@ -0,0 +1,42 @@
+'use client'
+
+import * as React from 'react'
+import { useRouter } from 'next/navigation'
+import { useT } from '@open-mercato/shared/lib/i18n/context'
+import { NotificationPanel } from '@open-mercato/ui/backend/notifications'
+import { useNotificationsPoll } from '@open-mercato/ui/backend/notifications'
+
+export function NotificationInboxPageClient() {
+  const t = useT()
+  const router = useRouter()
+  const {
+    notifications,
+    unreadCount,
+    markAsRead,
+    executeAction,
+    dismiss,
+    dismissUndo,
+    undoDismiss,
+    markAllRead,
+  } = useNotificationsPoll()
+
+  return (
+    <NotificationPanel
+      open
+      onOpenChange={(open) => {
+        if (!open) router.push('/backend')
+      }}
+      notifications={notifications}
+      unreadCount={unreadCount}
+      onMarkAsRead={markAsRead}
+      onExecuteAction={executeAction}
+      onDismiss={dismiss}
+      dismissUndo={dismissUndo}
+      onUndoDismiss={undoDismiss}
+      onMarkAllRead={markAllRead}
+      t={t}
+    />
+  )
+}
+
+export default NotificationInboxPageClient