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

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.',
-  },
-})

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
-}