@open-mercato/core 0.4.2-canary-15c0b23a3a → 0.4.2-canary-da2b080494

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

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

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

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

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

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

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

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

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

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

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