@goplusvn/core 0.1.52 → 0.1.54

package/src/notification/__tests__/notification-ui.test.tsx

@@ -0,0 +1,62 @@
+/**
+ * Smoke render chuông + hộp thư: mount thật (jsdom) với fetch giả — bắt lỗi
+ * import/hook sai trước khi app tiêu thụ, vì UI này chạy trong MainLayout của
+ * MỌI trang (vỡ là vỡ toàn app).
+ */
+import { fireEvent, render, screen, waitFor } from "@testing-library/react"
+import { beforeEach, describe, expect, it, vi } from "vitest"
+
+vi.mock("next/navigation", () => ({
+  useParams: () => ({ lang: "vi" }),
+  useRouter: () => ({ push: vi.fn() }),
+}))
+
+import { NotificationBell } from "../ui/notification-bell"
+import { NotificationsInbox } from "../ui/notifications-inbox"
+
+const ITEM = {
+  id: "n1",
+  type: "info",
+  category: "system",
+  title: "Đơn hàng mới",
+  content: "Đơn DH001 vừa được tạo",
+  url: "/sales-orders/1",
+  iconName: null,
+  isRead: false,
+  createdAt: new Date().toISOString(),
+}
+
+function mockFetch() {
+  global.fetch = vi.fn(async (input: RequestInfo | URL) => {
+    const url = String(input)
+    const body = url.includes("unread-count")
+      ? { count: 3 }
+      : { items: [ITEM], nextCursor: null, total: 1, unreadCount: 3 }
+    return new Response(JSON.stringify(body), {
+      status: 200,
+      headers: { "Content-Type": "application/json" },
+    })
+  }) as unknown as typeof fetch
+}
+
+describe("UI thông báo", () => {
+  beforeEach(() => mockFetch())
+
+  it("chuông render badge số chưa đọc", async () => {
+    render(<NotificationBell />)
+    expect(screen.getByLabelText("Thông báo")).toBeDefined()
+    await waitFor(() => expect(screen.getByRole("status").textContent).toBe("3"))
+  })
+
+  it("mở chuông: có tin + settingsSlot của app (vd toggle web push)", async () => {
+    render(<NotificationBell settingsSlot={<span>Bật thông báo đẩy</span>} />)
+    fireEvent.click(screen.getByLabelText("Thông báo"))
+    await waitFor(() => expect(screen.getByText("Đơn hàng mới")).toBeDefined())
+    expect(screen.getByText("Bật thông báo đẩy")).toBeDefined()
+  })
+
+  it("hộp thư render danh sách từ API", async () => {
+    render(<NotificationsInbox />)
+    await waitFor(() => expect(screen.getByText("Đơn hàng mới")).toBeDefined())
+  })
+})

package/src/notification/index.ts

@@ -1,14 +1,16 @@
+// Thông báo in-app — engine thật (thay bản mock InMemoryStorage cũ, không app
+// nào dùng). Bảng ship qua `goerp-features sync` (feature notifications).
+// App wiring mẫu: vinhhoa src/server/services/notification-service.ts
+// (configureNotificationService + afterNotify=web-push).
 export {
-  notificationService,
-  NotificationServiceImpl,
-} from "./notification-service";
-export { InMemoryStorage } from "./storage";
-export type {
-  Notification,
-  NotificationType,
-  NotificationChannel,
-  NotificationStatus,
-  CreateNotificationInput,
-  NotificationStorage,
-  NotificationServiceOptions,
-} from "./types";
+  configureNotificationService,
+  getUnreadCount,
+  listNotifications,
+  markAllRead,
+  markRead,
+  notify,
+  type ListParams,
+  type NotificationDb,
+  type NotificationType,
+  type NotifyInput,
+} from "./notification-service"

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"