@goplusvn/core 0.1.52 → 0.1.53

package/src/notification/notification-service.ts

@@ -1,120 +1,294 @@
-import type {
-  CreateNotificationInput,
-  Notification,
-  NotificationServiceOptions,
-  NotificationStorage,
-} from "./types";
-import { InMemoryStorage } from "./storage/in-memory";
-import { createLogger } from "../infrastructure/logger";
-import { eventBus } from "../infrastructure/event-bus";
-
-const logger = createLogger("NotificationService");
-
 /**
- * NotificationService - sends and manages user notifications
- *
- * @example
- * ```typescript
- * import { notificationService } from '@goerp/core/notification';
- *
- * // Send notification
- * await notificationService.send({
- *   userId: 'manager-123',
- *   title: 'Purchase Order cần duyệt',
- *   content: 'PO-001 chờ phê duyệt',
- *   type: 'approval',
- *   link: '/purchase-orders/PO-001'
- * });
+ * Thông báo in-app cho NHÂN VIÊN — engine dùng chung mọi app goerp (bảng
+ * `notifications` + `push_subscriptions` ship qua `goerp-features sync`,
+ * feature notifications). Thay bản mock InMemoryStorage cũ (đã xóa — không
+ * app nào dùng); đây là bản tôi luyện từ vinhhoa.
  *
- * // Get unread notifications
- * const unread = await notificationService.getUnread('manager-123');
+ * Triết lý: mọi hàm ghi (`notify`) là BEST-EFFORT và KHÔNG BAO GIỜ throw —
+ * thông báo lỗi không được phép chặn luồng nghiệp vụ (đơn/duyệt/thanh toán
+ * vẫn phải chạy). Fan-out ra nhiều người nhận ở tầng này (mỗi người 1 row).
  *
- * // Mark as read
- * await notificationService.markAsRead('notification-id');
- * ```
+ * App cắm qua `configureNotificationService({ db, afterNotify? })` (cùng
+ * khuôn configureTaskRunner): db là Prisma client có các model
+ * notification / rolePermission / userRole / userBranch / user (schema RBAC
+ * chung của goerp); `afterNotify` là seam fan-out thêm kênh (web push, email…)
+ * — chạy fire-and-forget sau khi ghi DB.
  */
-class NotificationServiceImpl {
-  private storage: NotificationStorage;
 
-  constructor(options: NotificationServiceOptions = {}) {
-    this.storage = options.storage || new InMemoryStorage();
-  }
+export type NotificationType =
+  | "info"
+  | "success"
+  | "warning"
+  | "error"
+  | "approval"
 
-  /** Set custom storage implementation */
-  setStorage(storage: NotificationStorage): void {
-    this.storage = storage;
-  }
+export interface NotifyInput {
+  /** Gửi trực tiếp tới các user id (bỏ qua giá trị falsy). */
+  userIds?: Array<string | null | undefined>
+  /** Gửi tới mọi user mang một trong các vai trò này. */
+  roleCodes?: string[]
+  /**
+   * Gửi tới mọi user mang các vai trò này BẤT KỂ chi nhánh — cho vai trò tập
+   * trung tại trụ sở (vd ACCOUNTANT) cần biết sự kiện của mọi CN.
+   */
+  roleCodesAllBranches?: string[]
+  /** Gửi tới mọi user CÓ QUYỀN resource:action (vd payment-request:approve_l2). */
+  permission?: { resourceCode: string; actionCode: string }
+  /**
+   * Giới hạn người nhận suy ra từ `roleCodes`/`permission` về đúng chi nhánh.
+   * KHÔNG áp cho `userIds` (đích chỉ định tường minh) và `roleCodesAllBranches`.
+   */
+  branchId?: string | null
+  /**
+   * Cách áp `branchId` cho nhóm suy-ra-từ-vai-trò:
+   *  - "member" (mặc định): user ĐƯỢC GÁN chi nhánh đó.
+   *  - "default": chi nhánh MẶC ĐỊNH của user (UserBranch.isDefault — nơi làm
+   *    việc chính) — chỉ báo đúng người PHỤ TRÁCH chi nhánh của chứng từ.
+   */
+  branchScope?: "member" | "default"
 
-  /** Send a notification */
-  async send(input: CreateNotificationInput): Promise<Notification> {
-    const notification: Notification = {
-      id: crypto.randomUUID(),
-      userId: input.userId,
-      title: input.title,
-      content: input.content,
-      type: input.type || "info",
-      channel: input.channel || "in-app",
-      status: "sent",
-      link: input.link,
-      metadata: input.metadata,
-      createdAt: new Date(),
-    };
-
-    await this.storage.save(notification);
-
-    logger.debug("Notification sent", {
-      id: notification.id,
-      userId: notification.userId,
-      type: notification.type,
-    });
-
-    // Emit event for real-time updates
-    eventBus.emit("notification.sent", { notification });
-
-    return notification;
-  }
+  type?: NotificationType
+  category?: string
+  title: string
+  content: string
+  url?: string
+  iconName?: string
+  resourceType?: string
+  resourceId?: string
+  /** Actor gây ra sự kiện (null = hệ thống). */
+  createdBy?: string | null
+  /** Đừng tự gửi thông báo cho chính người vừa thao tác. */
+  excludeUserId?: string | null
+  meta?: unknown
+}
 
-  /** Get all notifications for a user */
-  async getAll(userId: string): Promise<Notification[]> {
-    return this.storage.findByUserId(userId);
+/**
+ * Delegate Prisma tối thiểu — structural, args `any` CÓ CHỦ ĐÍCH (client
+ * Prisma sinh ra hẹp hơn structural type — bài học SettingsDb/TaskDb).
+ */
+export interface NotificationDb {
+  notification: {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    createMany(args: any): Promise<{ count: number }>
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    findMany(args: any): Promise<any[]>
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    count(args: any): Promise<number>
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    updateMany(args: any): Promise<{ count: number }>
+  }
+  rolePermission: {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    findMany(args: any): Promise<Array<{ roleCode: string }>>
+  }
+  userRole: {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    findMany(args: any): Promise<Array<{ userId: string }>>
+  }
+  userBranch: {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    findMany(args: any): Promise<Array<{ userId: string }>>
   }
+  user: {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    findMany(args: any): Promise<Array<{ id: string }>>
+  }
+}
+
+interface NotificationConfig {
+  db: NotificationDb
+  /**
+   * Fan-out kênh phụ (web push, email…) SAU khi ghi DB — fire-and-forget,
+   * lỗi tự nuốt (engine đã catch + log).
+   */
+  afterNotify?: (recipients: string[], input: NotifyInput) => Promise<unknown>
+}
+
+let config: NotificationConfig | null = null
 
-  /** Get unread notifications for a user */
-  async getUnread(userId: string): Promise<Notification[]> {
-    return this.storage.findByUserId(userId, { unreadOnly: true });
+export function configureNotificationService(next: NotificationConfig): void {
+  config = next
+}
+
+function requireConfig(): NotificationConfig {
+  if (!config) {
+    throw new Error(
+      "[notification] chưa configureNotificationService({ db, afterNotify? }) — gọi 1 lần lúc khởi tạo app.",
+    )
   }
+  return config
+}
+
+/**
+ * Suy ra danh sách userId người nhận (distinct, chỉ user đang hoạt động).
+ * Gộp: userIds tường minh ∪ (role/permission [∩ chi nhánh nếu có]).
+ */
+async function resolveRecipients(input: NotifyInput): Promise<string[]> {
+  const { db } = requireConfig()
+  const explicit = (input.userIds ?? []).filter(
+    (id): id is string => typeof id === "string" && id.length > 0,
+  )
 
-  /** Get unread count for a user */
-  async getUnreadCount(userId: string): Promise<number> {
-    const unread = await this.getUnread(userId);
-    return unread.length;
+  // Gom các roleCode: từ input.roleCodes + từ permission (resource:action).
+  const roleCodes = new Set<string>(input.roleCodes ?? [])
+  if (input.permission) {
+    const rp = await db.rolePermission.findMany({
+      where: {
+        resourceCode: input.permission.resourceCode,
+        actionCode: input.permission.actionCode,
+      },
+      select: { roleCode: true },
+    })
+    rp.forEach((r) => roleCodes.add(r.roleCode))
   }
 
-  /** Get a notification by ID */
-  async getById(id: string): Promise<Notification | null> {
-    return this.storage.findById(id);
+  let roleDerived: string[] = []
+  if (roleCodes.size > 0) {
+    const userRoles = await db.userRole.findMany({
+      where: { roleCode: { in: [...roleCodes] } },
+      select: { userId: true },
+    })
+    roleDerived = userRoles.map((u) => u.userId)
+
+    // Lọc theo chi nhánh nếu yêu cầu (chỉ áp cho nhóm suy-ra-từ-vai-trò).
+    if (input.branchId && roleDerived.length > 0) {
+      const inBranch = await db.userBranch.findMany({
+        where: {
+          branchId: input.branchId,
+          userId: { in: roleDerived },
+          ...(input.branchScope === "default" ? { isDefault: true } : {}),
+        },
+        select: { userId: true },
+      })
+      const allowed = new Set(inBranch.map((b) => b.userId))
+      roleDerived = roleDerived.filter((id) => allowed.has(id))
+    }
   }
 
-  /** Mark a notification as read */
-  async markAsRead(id: string): Promise<void> {
-    await this.storage.markAsRead(id);
-    eventBus.emit("notification.read", { id });
+  // Vai trò toàn cục (trụ sở): nhận bất kể chi nhánh, không qua lọc branchId.
+  let globalRoleDerived: string[] = []
+  if (input.roleCodesAllBranches?.length) {
+    const rows = await db.userRole.findMany({
+      where: { roleCode: { in: input.roleCodesAllBranches } },
+      select: { userId: true },
+    })
+    globalRoleDerived = rows.map((u) => u.userId)
   }
 
-  /** Mark all notifications as read for a user */
-  async markAllAsRead(userId: string): Promise<void> {
-    await this.storage.markAllAsRead(userId);
-    eventBus.emit("notification.allRead", { userId });
+  const candidates = [
+    ...new Set([...explicit, ...roleDerived, ...globalRoleDerived]),
+  ]
+  if (candidates.length === 0) return []
+
+  // Chỉ giữ user còn tồn tại & đang hoạt động (loại id rác / user bị khoá).
+  const valid = await db.user.findMany({
+    where: { id: { in: candidates }, isActive: true },
+    select: { id: true },
+  })
+  let ids = valid.map((u) => u.id)
+  if (input.excludeUserId) ids = ids.filter((id) => id !== input.excludeUserId)
+  return ids
+}
+
+/**
+ * Ghi thông báo cho (nhiều) người nhận. Trả về số row đã tạo. KHÔNG throw.
+ */
+export async function notify(input: NotifyInput): Promise<number> {
+  try {
+    const { db, afterNotify } = requireConfig()
+    const recipients = await resolveRecipients(input)
+    if (recipients.length === 0) return 0
+
+    const now = new Date()
+    await db.notification.createMany({
+      data: recipients.map((userId) => ({
+        userId,
+        type: input.type ?? "info",
+        category: input.category ?? null,
+        title: input.title,
+        content: input.content,
+        url: input.url ?? null,
+        iconName: input.iconName ?? null,
+        resourceType: input.resourceType ?? null,
+        resourceId: input.resourceId ?? null,
+        createdBy: input.createdBy ?? null,
+        meta: input.meta ?? undefined,
+        createdAt: now,
+      })),
+    })
+
+    // Kênh phụ (web push, email…) — fire-and-forget qua seam.
+    if (afterNotify) {
+      void afterNotify(recipients, input).catch((e) =>
+        console.error("[notification] afterNotify lỗi:", e),
+      )
+    }
+
+    return recipients.length
+  } catch (e) {
+    console.error("[notification] notify lỗi:", e)
+    return 0
   }
+}
+
+export async function getUnreadCount(userId: string): Promise<number> {
+  const { db } = requireConfig()
+  return db.notification.count({ where: { userId, isRead: false } })
+}
+
+export interface ListParams {
+  cursor?: string
+  take?: number
+  filter?: "all" | "unread"
+}
 
-  /** Delete a notification */
-  async delete(id: string): Promise<void> {
-    await this.storage.delete(id);
+/**
+ * Danh sách thông báo của CHÍNH user (cursor pagination theo createdAt desc).
+ * `nextCursor` = id của row cuối trang (null nếu hết).
+ */
+export async function listNotifications(userId: string, params: ListParams) {
+  const { db } = requireConfig()
+  const take = Math.min(Math.max(params.take ?? 20, 1), 50)
+  const where = {
+    userId,
+    ...(params.filter === "unread" ? { isRead: false } : {}),
   }
+
+  const rows = await db.notification.findMany({
+    where,
+    orderBy: [{ createdAt: "desc" }, { id: "desc" }],
+    take: take + 1, // lấy dư 1 để biết còn trang sau
+    ...(params.cursor ? { cursor: { id: params.cursor }, skip: 1 } : {}),
+  })
+
+  const hasMore = rows.length > take
+  const items = hasMore ? rows.slice(0, take) : rows
+  const nextCursor = hasMore ? (items[items.length - 1]?.id ?? null) : null
+
+  const [total, unreadCount] = await Promise.all([
+    db.notification.count({ where }),
+    db.notification.count({ where: { userId, isRead: false } }),
+  ])
+
+  return { items, nextCursor, total, unreadCount }
 }
 
-// Singleton instance
-export const notificationService = new NotificationServiceImpl();
+/** Đánh dấu đã đọc một số tin (scope theo user để không đọc hộ người khác). */
+export async function markRead(userId: string, ids: string[]): Promise<number> {
+  const { db } = requireConfig()
+  if (!ids.length) return 0
+  const res = await db.notification.updateMany({
+    where: { userId, id: { in: ids }, isRead: false },
+    data: { isRead: true, readAt: new Date() },
+  })
+  return res.count
+}
 
-// Export class for testing
-export { NotificationServiceImpl };
+export async function markAllRead(userId: string): Promise<number> {
+  const { db } = requireConfig()
+  const res = await db.notification.updateMany({
+    where: { userId, isRead: false },
+    data: { isRead: true, readAt: new Date() },
+  })
+  return res.count
+}

package/src/notification/ui/index.ts

@@ -0,0 +1,2 @@
+export { NotificationBell } from "./notification-bell"
+export { NotificationsInbox } from "./notifications-inbox"

package/src/notification/ui/notification-bell.tsx

@@ -0,0 +1,244 @@
+"use client"
+
+import { useEffect, useRef, useState } from "react"
+import type React from "react"
+import { useParams, useRouter } from "next/navigation"
+import {
+  Badge,
+  Button,
+  DynamicIcon,
+  Popover,
+  PopoverContent,
+  PopoverTrigger,
+  ScrollArea,
+} from "../../ui/primitives"
+import { toast } from "sonner"
+import useSWR from "swr"
+import { Bell, CheckCheck } from "lucide-react"
+
+
+/**
+ * Chuông thông báo in-app dùng chung mọi app goerp — truyền vào MainLayout qua
+ * prop `notificationSlot`. Engine + bảng: @goerp/core/notification + feature
+ * notifications; app cung cấp API mỏng (mẫu vinhhoa /api/notifications*).
+ * Tự fetch dữ liệu app:
+ *  - badge: poll GET /api/notifications/unread-count mỗi 45s
+ *  - list: fetch GET /api/notifications khi MỞ dropdown
+ *  - toast khi số chưa đọc tăng giữa 2 lần poll (tin mới)
+ * Không dùng SSE (nhất quán codebase — polling).
+ */
+
+interface NotiItem {
+  id: string
+  type: string
+  category: string | null
+  title: string
+  content: string
+  url: string | null
+  iconName: string | null
+  isRead: boolean
+  createdAt: string
+}
+interface ListResp {
+  items: NotiItem[]
+  nextCursor: string | null
+  total: number
+  unreadCount: number
+}
+
+const fetcher = (url: string) =>
+  fetch(url).then((r) => {
+    if (!r.ok) throw new Error(String(r.status))
+    return r.json()
+  })
+
+function timeAgo(d: string): string {
+  const s = Math.floor((Date.now() - new Date(d).getTime()) / 1000)
+  if (s < 60) return "vừa xong"
+  const m = Math.floor(s / 60)
+  if (m < 60) return `${m} phút trước`
+  const h = Math.floor(m / 60)
+  if (h < 24) return `${h} giờ trước`
+  const day = Math.floor(h / 24)
+  if (day < 7) return `${day} ngày trước`
+  return new Date(d).toLocaleDateString("vi-VN")
+}
+
+export function NotificationBell({
+  settingsSlot,
+}: {
+  /** Slot cài đặt dưới danh sách (vd toggle Web Push của app). */
+  settingsSlot?: React.ReactNode
+}) {
+  const router = useRouter()
+  const params = useParams()
+  const lang = (params?.lang as string) || "vi"
+  const [open, setOpen] = useState(false)
+
+  // Badge: poll số chưa đọc (nhẹ) — chạy nền kể cả khi đóng.
+  const { data: countData, mutate: mutateCount } = useSWR<{ count: number }>(
+    "/api/notifications/unread-count",
+    fetcher,
+    { refreshInterval: 45_000, revalidateOnFocus: true }
+  )
+  const unread = countData?.count ?? 0
+
+  // List: chỉ fetch khi mở dropdown.
+  const { data: listData, mutate: mutateList } = useSWR<ListResp>(
+    open ? "/api/notifications?take=10&filter=all" : null,
+    fetcher
+  )
+  const items = listData?.items ?? []
+
+  // Toast khi có tin mới (số chưa đọc tăng).
+  const prevUnread = useRef<number | null>(null)
+  useEffect(() => {
+    if (countData?.count == null) return
+    const cur = countData.count
+    if (prevUnread.current != null && cur > prevUnread.current) {
+      toast.info("Bạn có thông báo mới", {
+        description: `${cur} thông báo chưa đọc`,
+      })
+      if (open) void mutateList()
+    }
+    prevUnread.current = cur
+  }, [countData?.count, open, mutateList])
+
+  // Badge số trên icon PWA (iOS 16.4+/Android khi đã cài) — best-effort.
+  useEffect(() => {
+    if (!("setAppBadge" in navigator)) return
+    if (unread > 0) void navigator.setAppBadge(unread).catch(() => {})
+    else void navigator.clearAppBadge?.().catch(() => {})
+  }, [unread])
+
+  async function markRead(ids: string[]) {
+    try {
+      await fetch("/api/notifications/read", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ ids }),
+      })
+      void mutateCount()
+      void mutateList()
+    } catch {
+      /* best-effort */
+    }
+  }
+
+  async function markAllRead() {
+    try {
+      await fetch("/api/notifications/read", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ all: true }),
+      })
+      void mutateCount()
+      void mutateList()
+    } catch {
+      /* best-effort */
+    }
+  }
+
+  function onItemClick(n: NotiItem) {
+    if (!n.isRead) void markRead([n.id])
+    setOpen(false)
+    if (n.url) router.push(`/${lang}${n.url}`)
+  }
+
+  return (
+    <Popover open={open} onOpenChange={setOpen} modal>
+      <PopoverTrigger asChild>
+        <Button
+          variant="ghost"
+          size="icon"
+          className="relative"
+          aria-label="Thông báo"
+        >
+          <Bell className="size-4" />
+          {unread > 0 && (
+            <Badge
+              // top-0 (không thò LÊN khỏi nút) để header h-11 trong SidebarInset
+              // overflow-hidden KHÔNG cắt mất phần trên của badge; vẫn nằm góc
+              // trên-phải nút, thò nhẹ sang phải.
+              className="absolute top-0 -end-1 h-4 min-w-4 justify-center px-1 text-[10px] leading-none"
+              aria-live="polite"
+              role="status"
+            >
+              {unread > 99 ? "99+" : unread}
+            </Badge>
+          )}
+        </Button>
+      </PopoverTrigger>
+      <PopoverContent align="end" className="w-[380px] p-0">
+        <div className="flex items-center justify-between border-b border-border p-3">
+          <h3 className="text-sm font-semibold">Thông báo</h3>
+          {unread > 0 && (
+            <Button
+              variant="link"
+              className="h-auto gap-1 p-0 text-xs text-primary"
+              onClick={markAllRead}
+            >
+              <CheckCheck className="size-3.5" />
+              Đánh dấu đã đọc tất cả
+            </Button>
+          )}
+        </div>
+
+        <ScrollArea className="max-h-[340px]">
+          {items.length === 0 ? (
+            <p className="px-6 py-10 text-center text-sm text-muted-foreground">
+              Chưa có thông báo
+            </p>
+          ) : (
+            <ul className="divide-y divide-border">
+              {items.map((n) => (
+                <li key={n.id}>
+                  <button
+                    type="button"
+                    onClick={() => onItemClick(n)}
+                    className="flex w-full items-start gap-3 px-4 py-3 text-left hover:bg-accent hover:text-accent-foreground"
+                  >
+                    <span className="mt-0.5 flex size-9 shrink-0 items-center justify-center rounded-full bg-muted text-muted-foreground">
+                      <DynamicIcon
+                        name={(n.iconName as any) || "Bell"}
+                        className="size-4"
+                      />
+                    </span>
+                    <span className="min-w-0 flex-1">
+                      <span className="block truncate text-sm font-medium">
+                        {n.title}
+                      </span>
+                      <span className="mt-0.5 block text-xs text-muted-foreground line-clamp-2">
+                        {n.content}
+                      </span>
+                      <span className="mt-1 block text-[11px] text-muted-foreground">
+                        {timeAgo(n.createdAt)}
+                      </span>
+                    </span>
+                    {!n.isRead && (
+                      <span className="mt-1.5 size-2 shrink-0 rounded-full bg-primary" />
+                    )}
+                  </button>
+                </li>
+              ))}
+            </ul>
+          )}
+        </ScrollArea>
+
+        <div className="border-t border-border p-2">
+          {settingsSlot}
+          <Button
+            variant="ghost"
+            className="w-full text-sm text-primary"
+            onClick={() => {
+              setOpen(false)
+              router.push(`/${lang}/notifications`)
+            }}
+          >
+            Xem tất cả thông báo
+          </Button>
+        </div>
+      </PopoverContent>
+    </Popover>
+  )
+}