@open-mercato/core 0.4.2-canary-da2b080494 → 0.4.2-canary-19353c5970

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