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

package/src/modules/catalog/notifications.ts

@@ -0,0 +1,25 @@
+import type { NotificationTypeDefinition } from '@open-mercato/shared/modules/notifications/types'
+
+export const notificationTypes: NotificationTypeDefinition[] = [
+  {
+    type: 'catalog.product.low_stock',
+    module: 'catalog',
+    titleKey: 'catalog.notifications.product.lowStock.title',
+    bodyKey: 'catalog.notifications.product.lowStock.body',
+    icon: 'package-x',
+    severity: 'warning',
+    actions: [
+      {
+        id: 'view',
+        labelKey: 'common.view',
+        variant: 'outline',
+        href: '/backend/catalog/products/{sourceEntityId}',
+        icon: 'external-link',
+      },
+    ],
+    linkHref: '/backend/catalog/products/{sourceEntityId}',
+    expiresAfterHours: 72, // 3 days
+  },
+]
+
+export default notificationTypes

package/src/modules/catalog/subscribers/low-stock-notification.ts

@@ -0,0 +1,52 @@
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { resolveNotificationService } from '../../notifications/lib/notificationService'
+import { buildFeatureNotificationFromType } from '../../notifications/lib/notificationBuilder'
+import { notificationTypes } from '../notifications'
+
+export const metadata = {
+  event: 'catalog.product.stock_low',
+  persistent: true,
+  id: 'catalog:low-stock-notification',
+}
+
+type LowStockPayload = {
+  productId: string
+  productName: string
+  sku?: string | null
+  currentStock: number
+  threshold: number
+  tenantId: string
+  organizationId?: string | null
+}
+
+type ResolverContext = {
+  resolve: <T = unknown>(name: string) => T
+}
+
+export default async function handle(payload: LowStockPayload, ctx: ResolverContext) {
+  try {
+    const notificationService = resolveNotificationService(ctx)
+    const typeDef = notificationTypes.find((type) => type.type === 'catalog.product.low_stock')
+    if (!typeDef) return
+
+    const notificationInput = buildFeatureNotificationFromType(typeDef, {
+      requiredFeature: 'catalog.products.manage',
+      bodyVariables: {
+        productName: payload.productName,
+        sku: payload.sku ?? '',
+        currentStock: String(payload.currentStock),
+        threshold: String(payload.threshold),
+      },
+      sourceEntityType: 'catalog:product',
+      sourceEntityId: payload.productId,
+      linkHref: `/backend/catalog/products/${payload.productId}`,
+    })
+
+    await notificationService.createForFeature(notificationInput, {
+      tenantId: payload.tenantId,
+      organizationId: payload.organizationId ?? null,
+    })
+  } catch (err) {
+    console.error('[catalog:low-stock-notification] Failed to create notification:', err)
+  }
+}

package/src/modules/configs/cli.ts

@@ -2,6 +2,7 @@ import type { ModuleCli } from '@open-mercato/shared/modules/registry'
 import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
 import type { ModuleConfigService } from './lib/module-config-service'
 import { parseBooleanToken } from '@open-mercato/shared/lib/boolean'
+import { DEFAULT_NOTIFICATION_DELIVERY_CONFIG, NOTIFICATIONS_DELIVERY_CONFIG_KEY } from '../notifications/lib/deliveryConfig'
 
 function envDisablesAutoIndexing(): boolean {
   const raw = process.env.DISABLE_VECTOR_SEARCH_AUTOINDEXING
@@ -31,6 +32,11 @@ const restoreDefaults: ModuleCli = {
             name: 'auto_index_enabled',
             value: defaultEnabled,
           },
+          {
+            moduleId: 'notifications',
+            name: NOTIFICATIONS_DELIVERY_CONFIG_KEY,
+            value: DEFAULT_NOTIFICATION_DELIVERY_CONFIG,
+          },
         ],
         { force: true },
       )

package/src/modules/customers/commands/deals.ts

@@ -35,6 +35,9 @@ import { CrudHttpError } from '@open-mercato/shared/lib/crud/errors'
 import type { CrudIndexerConfig } from '@open-mercato/shared/lib/crud/types'
 import { E } from '#generated/entities.ids.generated'
 import { findWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import { resolveNotificationService } from '../../notifications/lib/notificationService'
+import { buildNotificationFromType } from '../../notifications/lib/notificationBuilder'
+import { notificationTypes } from '../notifications'
 
 const DEAL_ENTITY_ID = 'customers:customer_deal'
 const dealCrudIndexer: CrudIndexerConfig<CustomerDeal> = {
@@ -281,6 +284,8 @@ const updateDealCommand: CommandHandler<DealUpdateInput, { dealId: string }> = {
     ensureTenantScope(ctx, record.tenantId)
     ensureOrganizationScope(ctx, record.organizationId)
 
+    const previousStatus = record.status
+
     if (parsed.title !== undefined) record.title = parsed.title
     if (parsed.description !== undefined) record.description = parsed.description ?? null
     if (parsed.status !== undefined) record.status = parsed.status ?? record.status
@@ -319,6 +324,40 @@ const updateDealCommand: CommandHandler<DealUpdateInput, { dealId: string }> = {
       indexer: dealCrudIndexer,
     })
 
+    // Send notifications for deal won/lost status changes
+    const newStatus = record.status
+    const normalizedStatus = newStatus === 'win' ? 'won' : newStatus === 'loose' ? 'lost' : newStatus
+    if (previousStatus !== newStatus && (normalizedStatus === 'won' || normalizedStatus === 'lost') && record.ownerUserId) {
+      try {
+        const notificationService = resolveNotificationService(ctx.container)
+        const notificationType = normalizedStatus === 'won' ? 'customers.deal.won' : 'customers.deal.lost'
+        const typeDef = notificationTypes.find((type) => type.type === notificationType)
+        if (typeDef) {
+          const valueDisplay = record.valueAmount && record.valueCurrency
+            ? `${record.valueCurrency} ${record.valueAmount}`
+            : ''
+
+          const notificationInput = buildNotificationFromType(typeDef, {
+            recipientUserId: record.ownerUserId,
+            bodyVariables: {
+              dealTitle: record.title,
+              dealValue: valueDisplay,
+            },
+            sourceEntityType: 'customers:customer_deal',
+            sourceEntityId: record.id,
+            linkHref: `/backend/customers/deals/${record.id}`,
+          })
+
+          await notificationService.create(notificationInput, {
+            tenantId: record.tenantId,
+            organizationId: record.organizationId,
+          })
+        }
+      } catch {
+        // Notification creation is non-critical, don't fail the command
+      }
+    }
+
     return { dealId: record.id }
   },
   buildLog: async ({ snapshots, ctx }) => {

package/src/modules/customers/i18n/en.json

@@ -943,5 +943,9 @@
   "customers.workPlan.customerTodos.table.state.empty": "No customer tasks yet.",
   "customers.workPlan.customerTodos.table.error.load": "Failed to load customer tasks.",
   "customers.workPlan.customerTodos.table.export.view": "Exports the current list with filters and visible columns.",
-  "customers.workPlan.customerTodos.table.export.full": "Exports every linked task field, including hidden attributes."
+  "customers.workPlan.customerTodos.table.export.full": "Exports every linked task field, including hidden attributes.",
+  "customers.notifications.deal.won.title": "Deal Won",
+  "customers.notifications.deal.won.body": "{dealTitle} has been marked as won{dealValue, select, other { ({dealValue})}}",
+  "customers.notifications.deal.lost.title": "Deal Lost",
+  "customers.notifications.deal.lost.body": "{dealTitle} has been marked as lost"
 }

package/src/modules/customers/notifications.ts

@@ -0,0 +1,44 @@
+import type { NotificationTypeDefinition } from '@open-mercato/shared/modules/notifications/types'
+
+export const notificationTypes: NotificationTypeDefinition[] = [
+  {
+    type: 'customers.deal.won',
+    module: 'customers',
+    titleKey: 'customers.notifications.deal.won.title',
+    bodyKey: 'customers.notifications.deal.won.body',
+    icon: 'trophy',
+    severity: 'success',
+    actions: [
+      {
+        id: 'view',
+        labelKey: 'common.view',
+        variant: 'outline',
+        href: '/backend/customers/deals/{sourceEntityId}',
+        icon: 'external-link',
+      },
+    ],
+    linkHref: '/backend/customers/deals/{sourceEntityId}',
+    expiresAfterHours: 168, // 7 days
+  },
+  {
+    type: 'customers.deal.lost',
+    module: 'customers',
+    titleKey: 'customers.notifications.deal.lost.title',
+    bodyKey: 'customers.notifications.deal.lost.body',
+    icon: 'x-circle',
+    severity: 'warning',
+    actions: [
+      {
+        id: 'view',
+        labelKey: 'common.view',
+        variant: 'outline',
+        href: '/backend/customers/deals/{sourceEntityId}',
+        icon: 'external-link',
+      },
+    ],
+    linkHref: '/backend/customers/deals/{sourceEntityId}',
+    expiresAfterHours: 168, // 7 days
+  },
+]
+
+export default notificationTypes

package/src/modules/notifications/acl.ts

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

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

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

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

package/src/modules/notifications/api/[id]/restore/route.ts

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

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

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

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

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