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

package/src/modules/notifications/lib/deliveryConfig.ts

@@ -0,0 +1,153 @@
+import type { ModuleConfigService } from '@open-mercato/core/modules/configs/lib/module-config-service'
+import { parseBooleanWithDefault } from '@open-mercato/shared/lib/boolean'
+import { notificationDeliveryConfigSchema, type NotificationDeliveryConfigInput } from '../data/validators'
+
+export const NOTIFICATIONS_DELIVERY_CONFIG_KEY = 'delivery_strategies'
+
+export type NotificationDeliveryStrategyState = {
+  enabled: boolean
+}
+
+export type NotificationCustomDeliveryConfig = {
+  enabled?: boolean
+  config?: unknown
+}
+
+export type NotificationEmailDeliveryConfig = NotificationDeliveryStrategyState & {
+  from?: string
+  replyTo?: string
+  subjectPrefix?: string
+}
+
+export type NotificationDeliveryConfig = {
+  appUrl?: string
+  panelPath: string
+  strategies: {
+    database: NotificationDeliveryStrategyState
+    email: NotificationEmailDeliveryConfig
+    custom?: Record<string, NotificationCustomDeliveryConfig>
+  }
+}
+
+const envString = (value: string | undefined | null) => {
+  if (!value) return undefined
+  const trimmed = value.trim()
+  return trimmed.length ? trimmed : undefined
+}
+
+const resolveEnvDefaults = () => {
+  const appUrl = envString(
+    process.env.NOTIFICATIONS_APP_URL ||
+    process.env.APPLICATION_URL ||
+    process.env.NEXT_PUBLIC_APP_URL ||
+    process.env.APP_URL
+  )
+  const panelPath = envString(process.env.NOTIFICATIONS_PANEL_PATH)
+  const emailEnabled = parseBooleanWithDefault(process.env.NOTIFICATIONS_EMAIL_ENABLED, true)
+  const emailFrom = envString(process.env.NOTIFICATIONS_EMAIL_FROM || process.env.EMAIL_FROM)
+  const emailReplyTo = envString(process.env.NOTIFICATIONS_EMAIL_REPLY_TO || process.env.ADMIN_EMAIL)
+  const emailSubjectPrefix = envString(process.env.NOTIFICATIONS_EMAIL_SUBJECT_PREFIX)
+
+  return {
+    appUrl,
+    panelPath,
+    emailEnabled,
+    emailFrom,
+    emailReplyTo,
+    emailSubjectPrefix,
+  }
+}
+
+export const DEFAULT_NOTIFICATION_DELIVERY_CONFIG: NotificationDeliveryConfig = (() => {
+  const env = resolveEnvDefaults()
+  return {
+    appUrl: env.appUrl,
+    panelPath: env.panelPath ?? '/backend/notifications',
+    strategies: {
+      database: { enabled: true },
+      email: {
+        enabled: env.emailEnabled,
+        from: env.emailFrom,
+        replyTo: env.emailReplyTo,
+        subjectPrefix: env.emailSubjectPrefix,
+      },
+      custom: {},
+    },
+  }
+})()
+
+const normalizeDeliveryConfig = (input?: unknown | null): NotificationDeliveryConfig => {
+  const parsed = notificationDeliveryConfigSchema.safeParse(input ?? {})
+  if (!parsed.success) {
+    return { ...DEFAULT_NOTIFICATION_DELIVERY_CONFIG }
+  }
+
+  const value = parsed.data ?? {}
+  const strategies = value.strategies ?? {}
+
+  return {
+    appUrl: value.appUrl,
+    panelPath: value.panelPath ?? DEFAULT_NOTIFICATION_DELIVERY_CONFIG.panelPath,
+    strategies: {
+      database: {
+        enabled: DEFAULT_NOTIFICATION_DELIVERY_CONFIG.strategies.database.enabled,
+      },
+      email: {
+        enabled: strategies.email?.enabled ?? DEFAULT_NOTIFICATION_DELIVERY_CONFIG.strategies.email.enabled,
+        from: strategies.email?.from,
+        replyTo: strategies.email?.replyTo,
+        subjectPrefix: strategies.email?.subjectPrefix,
+      },
+      custom: strategies.custom ?? {},
+    },
+  }
+}
+
+type Resolver = {
+  resolve: <T = unknown>(name: string) => T
+}
+
+export async function resolveNotificationDeliveryConfig(
+  resolver: Resolver,
+  options?: { defaultValue?: NotificationDeliveryConfig }
+): Promise<NotificationDeliveryConfig> {
+  const fallback = options?.defaultValue ?? DEFAULT_NOTIFICATION_DELIVERY_CONFIG
+  let service: ModuleConfigService
+  try {
+    service = resolver.resolve<ModuleConfigService>('moduleConfigService')
+  } catch {
+    return { ...fallback }
+  }
+  try {
+    const value = await service.getValue('notifications', NOTIFICATIONS_DELIVERY_CONFIG_KEY, { defaultValue: fallback })
+    return normalizeDeliveryConfig(value)
+  } catch {
+    return { ...fallback }
+  }
+}
+
+export async function saveNotificationDeliveryConfig(
+  resolver: Resolver,
+  config: NotificationDeliveryConfigInput
+): Promise<void> {
+  let service: ModuleConfigService
+  try {
+    service = resolver.resolve<ModuleConfigService>('moduleConfigService')
+  } catch {
+    throw new Error('Configuration service unavailable')
+  }
+
+  const normalized = normalizeDeliveryConfig(config)
+  await service.setValue('notifications', NOTIFICATIONS_DELIVERY_CONFIG_KEY, normalized)
+}
+
+export function resolveNotificationPanelUrl(config: NotificationDeliveryConfig): string | null {
+  const base = config.appUrl
+    || process.env.APPLICATION_URL
+    || process.env.NEXT_PUBLIC_APP_URL
+    || process.env.APP_URL
+  if (!base || !base.trim()) {
+    return config.panelPath
+  }
+  return `${base.replace(/\/$/, '')}${config.panelPath}`
+}

package/src/modules/notifications/lib/deliveryStrategies.ts

@@ -0,0 +1,50 @@
+import type { Notification } from '../data/entities'
+import type { NotificationDeliveryConfig } from './deliveryConfig'
+
+export type NotificationDeliveryStrategyConfig = {
+  enabled?: boolean
+  config?: unknown
+}
+
+export type NotificationDeliveryRecipient = {
+  email?: string | null
+  name?: string | null
+}
+
+export type NotificationDeliveryContext = {
+  notification: Notification
+  recipient: NotificationDeliveryRecipient
+  title: string
+  body: string | null
+  panelUrl: string | null
+  panelLink: string | null
+  actionLinks: Array<{ id: string; label: string; href: string }>
+  deliveryConfig: NotificationDeliveryConfig
+  config: NotificationDeliveryStrategyConfig
+  resolve: <T = unknown>(name: string) => T
+  t: (key: string, fallback?: string, variables?: Record<string, string>) => string
+}
+
+export type NotificationDeliveryStrategy = {
+  id: string
+  label?: string
+  defaultEnabled?: boolean
+  deliver: (ctx: NotificationDeliveryContext) => Promise<void> | void
+}
+
+type RegisteredStrategy = NotificationDeliveryStrategy & { priority: number }
+
+const registry: RegisteredStrategy[] = []
+
+export function registerNotificationDeliveryStrategy(
+  strategy: NotificationDeliveryStrategy,
+  options?: { priority?: number }
+): void {
+  const priority = options?.priority ?? 0
+  registry.push({ ...strategy, priority })
+  registry.sort((a, b) => b.priority - a.priority)
+}
+
+export function getNotificationDeliveryStrategies(): NotificationDeliveryStrategy[] {
+  return registry
+}

package/src/modules/notifications/lib/events.ts

@@ -0,0 +1,48 @@
+export const NOTIFICATION_EVENTS = {
+  CREATED: 'notifications.created',
+  READ: 'notifications.read',
+  ACTIONED: 'notifications.actioned',
+  DISMISSED: 'notifications.dismissed',
+  RESTORED: 'notifications.restored',
+  EXPIRED: 'notifications.expired',
+} as const
+
+export type NotificationCreatedPayload = {
+  notificationId: string
+  recipientUserId: string
+  type: string
+  title: string
+  tenantId: string
+  organizationId?: string | null
+}
+
+export type NotificationReadPayload = {
+  notificationId: string
+  userId: string
+  tenantId: string
+}
+
+export type NotificationActionedPayload = {
+  notificationId: string
+  actionId: string
+  userId: string
+  tenantId: string
+}
+
+export type NotificationDismissedPayload = {
+  notificationId: string
+  userId: string
+  tenantId: string
+}
+
+export type NotificationRestoredPayload = {
+  notificationId: string
+  userId: string
+  tenantId: string
+  status: 'read' | 'unread'
+}
+
+export type NotificationExpiredPayload = {
+  notificationIds: string[]
+  tenantId: string
+}

package/src/modules/notifications/lib/notificationBuilder.ts

@@ -0,0 +1,121 @@
+import type { NotificationTypeDefinition, NotificationTypeAction } from '@open-mercato/shared/modules/notifications/types'
+import type { CreateNotificationInput, CreateBatchNotificationInput, CreateRoleNotificationInput, CreateFeatureNotificationInput } from '../data/validators'
+
+/**
+ * Transform type definition actions to API input actions.
+ * Type definitions use labelKey (i18n-first), while API input uses label with optional labelKey.
+ */
+function mapActions(actions: NotificationTypeAction[] | undefined) {
+  if (!actions || actions.length === 0) return undefined
+  return actions.map((action) => ({
+    id: action.id,
+    label: action.labelKey,
+    labelKey: action.labelKey,
+    variant: action.variant,
+    icon: action.icon,
+    commandId: action.commandId,
+    href: action.href,
+    confirmRequired: action.confirmRequired,
+    confirmMessage: action.confirmMessageKey,
+  }))
+}
+
+/**
+ * Common options for building notifications from type definitions
+ */
+interface CommonBuildOptions {
+  titleVariables?: Record<string, string>
+  bodyVariables?: Record<string, string>
+  sourceEntityType?: string
+  sourceEntityId?: string
+  linkHref?: string
+  groupKey?: string
+  expiresAt?: string
+}
+
+/**
+ * Build base notification fields from a type definition.
+ * Shared logic used by all notification builder functions.
+ */
+function buildBaseNotificationFields(
+  typeDef: NotificationTypeDefinition,
+  options: CommonBuildOptions
+) {
+  return {
+    type: typeDef.type,
+    titleKey: typeDef.titleKey,
+    bodyKey: typeDef.bodyKey,
+    titleVariables: options.titleVariables,
+    bodyVariables: options.bodyVariables,
+    title: typeDef.titleKey,
+    body: typeDef.bodyKey,
+    icon: typeDef.icon,
+    severity: typeDef.severity,
+    actions: mapActions(typeDef.actions),
+    primaryActionId: typeDef.primaryActionId,
+    sourceModule: typeDef.module,
+    sourceEntityType: options.sourceEntityType,
+    sourceEntityId: options.sourceEntityId,
+    linkHref: options.linkHref ?? typeDef.linkHref,
+    groupKey: options.groupKey,
+    expiresAt: options.expiresAt ?? (
+      typeDef.expiresAfterHours
+        ? new Date(Date.now() + typeDef.expiresAfterHours * 60 * 60 * 1000).toISOString()
+        : undefined
+    ),
+  }
+}
+
+/**
+ * Build a notification input from a type definition with i18n support.
+ * This is the recommended way to create notifications - use type definitions from notifications.ts
+ * to ensure i18n-first approach.
+ */
+export function buildNotificationFromType(
+  typeDef: NotificationTypeDefinition,
+  options: CommonBuildOptions & { recipientUserId: string }
+): CreateNotificationInput {
+  return {
+    recipientUserId: options.recipientUserId,
+    ...buildBaseNotificationFields(typeDef, options),
+  }
+}
+
+/**
+ * Build a batch notification input from a type definition
+ */
+export function buildBatchNotificationFromType(
+  typeDef: NotificationTypeDefinition,
+  options: CommonBuildOptions & { recipientUserIds: string[] }
+): CreateBatchNotificationInput {
+  return {
+    recipientUserIds: options.recipientUserIds,
+    ...buildBaseNotificationFields(typeDef, options),
+  }
+}
+
+/**
+ * Build a role notification input from a type definition
+ */
+export function buildRoleNotificationFromType(
+  typeDef: NotificationTypeDefinition,
+  options: CommonBuildOptions & { roleId: string }
+): CreateRoleNotificationInput {
+  return {
+    roleId: options.roleId,
+    ...buildBaseNotificationFields(typeDef, options),
+  }
+}
+
+/**
+ * Build a feature-based notification input from a type definition
+ */
+export function buildFeatureNotificationFromType(
+  typeDef: NotificationTypeDefinition,
+  options: CommonBuildOptions & { requiredFeature: string }
+): CreateFeatureNotificationInput {
+  return {
+    requiredFeature: options.requiredFeature,
+    ...buildBaseNotificationFields(typeDef, options),
+  }
+}

package/src/modules/notifications/lib/notificationFactory.ts

@@ -0,0 +1,76 @@
+import type { EntityManager } from '@mikro-orm/core'
+import { Notification } from '../data/entities'
+import type { CreateNotificationInput } from '../data/validators'
+import { NOTIFICATION_EVENTS } from './events'
+import { assertSafeNotificationHref, sanitizeNotificationActions } from './safeHref'
+
+export type NotificationContentInput = Omit<CreateNotificationInput, 'recipientUserId'>
+
+export type NotificationTenantContext = {
+  tenantId: string
+  organizationId?: string | null
+}
+
+export function buildNotificationEntity(
+  em: EntityManager,
+  input: NotificationContentInput,
+  recipientUserId: string,
+  ctx: NotificationTenantContext
+): Notification {
+  const actions = sanitizeNotificationActions(input.actions)
+  const linkHref = assertSafeNotificationHref(input.linkHref)
+
+  return em.create(Notification, {
+    recipientUserId,
+    type: input.type,
+    // i18n-first: store keys and variables for translation at display time
+    titleKey: input.titleKey,
+    bodyKey: input.bodyKey,
+    titleVariables: input.titleVariables,
+    bodyVariables: input.bodyVariables,
+    // Fallback text (required for backward compatibility)
+    title: input.title || input.titleKey || '',
+    body: input.body,
+    icon: input.icon,
+    severity: input.severity ?? 'info',
+    actionData: actions
+      ? {
+          actions,
+          primaryActionId: input.primaryActionId,
+        }
+      : null,
+    sourceModule: input.sourceModule,
+    sourceEntityType: input.sourceEntityType,
+    sourceEntityId: input.sourceEntityId,
+    linkHref,
+    groupKey: input.groupKey,
+    expiresAt: input.expiresAt ? new Date(input.expiresAt) : null,
+    tenantId: ctx.tenantId,
+    organizationId: ctx.organizationId,
+  })
+}
+
+export async function emitNotificationCreated(
+  eventBus: { emit: (event: string, payload: unknown) => Promise<void> },
+  notification: Notification,
+  ctx: NotificationTenantContext
+): Promise<void> {
+  await eventBus.emit(NOTIFICATION_EVENTS.CREATED, {
+    notificationId: notification.id,
+    recipientUserId: notification.recipientUserId,
+    type: notification.type,
+    title: notification.title,
+    tenantId: ctx.tenantId,
+    organizationId: ctx.organizationId,
+  })
+}
+
+export async function emitNotificationCreatedBatch(
+  eventBus: { emit: (event: string, payload: unknown) => Promise<void> },
+  notifications: Notification[],
+  ctx: NotificationTenantContext
+): Promise<void> {
+  for (const notification of notifications) {
+    await emitNotificationCreated(eventBus, notification, ctx)
+  }
+}

package/src/modules/notifications/lib/notificationMapper.ts

@@ -0,0 +1,33 @@
+import type { NotificationDto } from '@open-mercato/shared/modules/notifications/types'
+import { Notification } from '../data/entities'
+
+export function toNotificationDto(notification: Notification): NotificationDto {
+  return {
+    id: notification.id,
+    type: notification.type,
+    title: notification.title,
+    body: notification.body,
+    titleKey: notification.titleKey,
+    bodyKey: notification.bodyKey,
+    titleVariables: notification.titleVariables,
+    bodyVariables: notification.bodyVariables,
+    icon: notification.icon,
+    severity: notification.severity,
+    status: notification.status,
+    actions: notification.actionData?.actions?.map((action) => ({
+      id: action.id,
+      label: action.label,
+      labelKey: action.labelKey,
+      variant: action.variant,
+      icon: action.icon,
+    })) ?? [],
+    primaryActionId: notification.actionData?.primaryActionId,
+    sourceModule: notification.sourceModule,
+    sourceEntityType: notification.sourceEntityType,
+    sourceEntityId: notification.sourceEntityId,
+    linkHref: notification.linkHref,
+    createdAt: notification.createdAt.toISOString(),
+    readAt: notification.readAt?.toISOString() ?? null,
+    actionTaken: notification.actionTaken,
+  }
+}

package/src/modules/notifications/lib/notificationRecipients.ts

@@ -0,0 +1,83 @@
+import type { Knex } from 'knex'
+import { hasFeature } from '@open-mercato/shared/security/features'
+
+interface AclRow {
+  user_id: string
+  features_json: unknown
+  is_super_admin: boolean
+}
+
+function normalizeFeatures(features: unknown): string[] | undefined {
+  if (!Array.isArray(features)) return undefined
+  const normalized = features.filter((feature): feature is string => typeof feature === 'string')
+  return normalized.length ? normalized : undefined
+}
+
+/**
+ * Extract user IDs from ACL rows that have the required feature or are super admins.
+ */
+function collectUsersWithFeature(
+  userIdsSet: Set<string>,
+  rows: AclRow[],
+  requiredFeature: string
+): void {
+  for (const row of rows) {
+    if (row.is_super_admin) {
+      userIdsSet.add(row.user_id)
+      continue
+    }
+
+    const features = normalizeFeatures(row.features_json)
+    if (features && hasFeature(features, requiredFeature)) {
+      userIdsSet.add(row.user_id)
+    }
+  }
+}
+
+export async function getRecipientUserIdsForRole(
+  knex: Knex,
+  tenantId: string,
+  roleId: string
+): Promise<string[]> {
+  const userRoles = await knex('user_roles')
+    .join('users', 'user_roles.user_id', 'users.id')
+    .where('user_roles.role_id', roleId)
+    .whereNull('user_roles.deleted_at')
+    .whereNull('users.deleted_at')
+    .where('users.tenant_id', tenantId)
+    .select('users.id as user_id')
+
+  return userRoles.map((row: { user_id: string }) => row.user_id)
+}
+
+export async function getRecipientUserIdsForFeature(
+  knex: Knex,
+  tenantId: string,
+  requiredFeature: string
+): Promise<string[]> {
+  const userIdsSet = new Set<string>()
+
+  const userAcls = await knex('user_acls')
+    .join('users', 'user_acls.user_id', 'users.id')
+    .where('user_acls.tenant_id', tenantId)
+    .whereNull('user_acls.deleted_at')
+    .whereNull('users.deleted_at')
+    .where('users.tenant_id', tenantId)
+    .select('users.id as user_id', 'user_acls.features_json', 'user_acls.is_super_admin')
+
+  collectUsersWithFeature(userIdsSet, userAcls, requiredFeature)
+
+  const roleAcls = await knex('role_acls')
+    .join('user_roles', 'role_acls.role_id', 'user_roles.role_id')
+    .join('users', 'user_roles.user_id', 'users.id')
+    .where('role_acls.tenant_id', tenantId)
+    .whereNull('role_acls.deleted_at')
+    .whereNull('user_roles.deleted_at')
+    .whereNull('users.deleted_at')
+    .where('users.tenant_id', tenantId)
+    .select('users.id as user_id', 'role_acls.features_json', 'role_acls.is_super_admin')
+
+  collectUsersWithFeature(userIdsSet, roleAcls, requiredFeature)
+
+  return Array.from(userIdsSet)
+}