@goplusvn/core 0.1.52 → 0.1.54

package/src/cron/db-cron-manager.ts

@@ -0,0 +1,459 @@
+import { SimpleCronJob } from "../infrastructure/cron/cron-manager";
+
+import type {
+  CronJob,
+  CronJobManager,
+  CronJobOptions,
+} from "../infrastructure/cron/types";
+
+/**
+ * Cron CÓ TRẠNG THÁI TRONG DB — engine dùng chung mọi app goerp (bảng
+ * `system_jobs` + `job_execution_logs` ship qua `goerp-features sync`, feature
+ * system-jobs). Bản `infrastructure/cron` chỉ hẹn giờ trong RAM: restart là
+ * mất bật/tắt, không có lịch sử chạy, admin không nhìn thấy gì.
+ *
+ * Vai trò từng lớp:
+ *  - `SimpleCronJob` (infrastructure): bấm giờ setInterval thuần.
+ *  - lớp này: DB là NGUỒN SỰ THẬT của cờ enabled + cronTime, bọc mỗi lần chạy
+ *    thành 1 row `job_execution_logs` (running → success|failed, kèm actions
+ *    do job tự ghi qua `getJobExecutionContext().log()`).
+ *
+ * App cắm qua `configureCronManager({ db, logger? })` (cùng khuôn
+ * configureTaskRunner/configureNotificationService), rồi đăng ký job trong
+ * `instrumentation.ts`.
+ *
+ * BỀN VỚI APP CHƯA SYNC FEATURE: thiếu model systemJob/jobExecutionLog thì
+ * chạy chế độ memory-only thay vì nổ — cron là hạ tầng nền, không được làm
+ * chết boot.
+ */
+
+export interface ActionLog {
+  time: string;
+  action: string;
+  details?: string;
+}
+
+/** Ngữ cảnh của LẦN CHẠY hiện tại — job dùng để ghi diễn biến vào log. */
+export interface JobExecutionContext {
+  logId: string;
+  jobName: string;
+  startedAt: Date;
+  actions: ActionLog[];
+  log: (action: string, details?: string) => void;
+}
+
+/**
+ * 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).
+ * Cả 2 model đều optional: app chưa `goerp-features sync` vẫn chạy được.
+ */
+export interface CronDb {
+  systemJob?: {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    count(args?: any): Promise<number>;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    findUnique(args: any): Promise<any>;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    create(args: any): Promise<any>;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    update(args: any): Promise<any>;
+  };
+  jobExecutionLog?: {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    create(args: any): Promise<any>;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    update(args: any): Promise<any>;
+  };
+}
+
+export interface CronLogger {
+  info(message: string, meta?: unknown): void;
+  warn(message: string, meta?: unknown): void;
+  error(message: string, meta?: unknown): void;
+}
+
+interface CronConfig {
+  db: CronDb;
+  /** Bỏ trống thì dùng console (prefix [cron]). */
+  logger?: CronLogger;
+}
+
+const consoleLogger: CronLogger = {
+  info: (m, meta) => console.info(`[cron] ${m}`, meta ?? ""),
+  warn: (m, meta) => console.warn(`[cron] ${m}`, meta ?? ""),
+  error: (m, meta) => console.error(`[cron] ${m}`, meta ?? ""),
+};
+
+let config: CronConfig | null = null;
+
+export function configureCronManager(next: CronConfig): void {
+  config = next;
+}
+
+function requireConfig(): CronConfig {
+  if (!config) {
+    throw new Error(
+      "[cron] chưa configureCronManager({ db, logger? }) — gọi 1 lần lúc khởi tạo app (instrumentation).",
+    );
+  }
+  return config;
+}
+
+function log(): CronLogger {
+  return config?.logger ?? consoleLogger;
+}
+
+let currentExecutionContext: JobExecutionContext | null = null;
+
+/** Job đang chạy gọi để ghi diễn biến vào `job_execution_logs.actions`. */
+export function getJobExecutionContext(): JobExecutionContext | null {
+  return currentExecutionContext;
+}
+
+export class DbCronJobManager implements CronJobManager {
+  private jobs = new Map<string, CronJob>();
+  /** onTick GỐC của app — giữ để updateJob dựng lại job với cronTime mới. */
+  private jobCallbacks = new Map<string, () => void | Promise<void>>();
+  /** onTick ĐÃ BỌC (ghi log) — "chạy ngay" phải dùng bản này để có lịch sử. */
+  private wrappedCallbacks = new Map<string, () => void | Promise<void>>();
+  private isInitialized = false;
+
+  async init(): Promise<void> {
+    if (this.isInitialized) return;
+    try {
+      const { db } = requireConfig();
+      if (db.systemJob) {
+        const jobsCount = await db.systemJob.count();
+        log().info("DbCronJobManager initialized", { jobsCount });
+      } else {
+        log().warn(
+          "Thiếu model SystemJob (app chưa goerp-features sync system-jobs) — cron chạy memory-only",
+        );
+      }
+    } catch (error) {
+      log().error("Khởi tạo DbCronJobManager lỗi", error);
+    } finally {
+      // Đánh dấu đã init kể cả khi lỗi — tránh vòng lặp thử lại mỗi request.
+      this.isInitialized = true;
+    }
+  }
+
+  /**
+   * Bọc onTick: mở row execution log → chạy → đóng row (success/failed) và
+   * cập nhật trạng thái job. Dùng CHUNG cho addJob/updateJob/chạy-tay để
+   * mọi đường chạy đều để lại lịch sử.
+   */
+  private wrapOnTick(
+    name: string,
+    onTick: () => void | Promise<void>,
+  ): () => Promise<void> {
+    return async () => {
+      const { db } = requireConfig();
+      const startedAt = new Date();
+      let logId: string | null = null;
+
+      if (db.jobExecutionLog) {
+        try {
+          const entry = await db.jobExecutionLog.create({
+            data: { jobName: name, startedAt, status: "running", actions: [] },
+          });
+          logId = entry.id;
+        } catch (e) {
+          log().error(`Tạo execution log cho ${name} lỗi`, e);
+        }
+      }
+
+      const actions: ActionLog[] = [];
+      currentExecutionContext = {
+        logId: logId ?? "",
+        jobName: name,
+        startedAt,
+        actions,
+        log: (action, details) =>
+          actions.push({ time: new Date().toISOString(), action, details }),
+      };
+
+      await this.recordJobRun(name, "running");
+
+      try {
+        await onTick();
+        const finishedAt = new Date();
+        await this.closeExecutionLog(logId, name, {
+          finishedAt,
+          durationMs: finishedAt.getTime() - startedAt.getTime(),
+          status: "success",
+          actions,
+        });
+        await this.recordJobRun(name, "idle", finishedAt);
+      } catch (error) {
+        const finishedAt = new Date();
+        await this.closeExecutionLog(logId, name, {
+          finishedAt,
+          durationMs: finishedAt.getTime() - startedAt.getTime(),
+          status: "failed",
+          actions,
+          error: String(error),
+        });
+        await this.recordJobRun(name, "failed", undefined, String(error));
+        throw error;
+      } finally {
+        currentExecutionContext = null;
+      }
+    };
+  }
+
+  private async closeExecutionLog(
+    logId: string | null,
+    name: string,
+    result: {
+      finishedAt: Date;
+      durationMs: number;
+      status: "success" | "failed";
+      actions: ActionLog[];
+      error?: string;
+    },
+  ): Promise<void> {
+    const { db } = requireConfig();
+    if (!logId || !db.jobExecutionLog) return;
+    try {
+      await db.jobExecutionLog.update({
+        where: { id: logId },
+        data: {
+          finishedAt: result.finishedAt,
+          durationMs: result.durationMs,
+          status: result.status,
+          actions: result.actions,
+          error: result.error,
+          summary:
+            result.status === "success"
+              ? `Completed in ${result.durationMs}ms with ${result.actions.length} actions`
+              : `Failed after ${result.durationMs}ms: ${result.error}`,
+        },
+      });
+    } catch (e) {
+      log().error(`Cập nhật execution log cho ${name} lỗi`, e);
+    }
+  }
+
+  addJob(options: CronJobOptions): CronJob {
+    this.jobCallbacks.set(options.name, options.onTick);
+
+    const wrappedOnTick = this.wrapOnTick(options.name, options.onTick);
+    const wrappedOptions: CronJobOptions = {
+      ...options,
+      onTick: wrappedOnTick,
+    };
+
+    const job = new SimpleCronJob(wrappedOptions);
+    this.jobs.set(options.name, job);
+    this.wrappedCallbacks.set(options.name, wrappedOnTick);
+
+    // Đồng bộ DB bất đồng bộ: DB quyết định job có chạy hay không.
+    void this.syncJobWithDb(wrappedOptions, job).catch((e) =>
+      log().error(`Đồng bộ job ${options.name} lỗi`, e),
+    );
+
+    return job;
+  }
+
+  private async syncJobWithDb(
+    options: CronJobOptions,
+    job: CronJob,
+    /** Ý chí ADMIN (updateJob truyền vào) — ghi đè cờ enabled đang có trong DB. */
+    enabledOverride?: boolean,
+  ): Promise<void> {
+    const { db } = requireConfig();
+    if (!db.systemJob) {
+      if ((enabledOverride ?? options.start ?? true) !== false) job.start();
+      return;
+    }
+
+    try {
+      let dbJob = await db.systemJob.findUnique({
+        where: { name: options.name },
+      });
+
+      if (!dbJob) {
+        dbJob = await db.systemJob.create({
+          data: {
+            name: options.name,
+            cronTime: options.cronTime,
+            enabled: enabledOverride ?? options.start ?? true,
+            status: "idle",
+          },
+        });
+      } else if (
+        enabledOverride !== undefined &&
+        dbJob.enabled !== enabledOverride
+      ) {
+        // Không ghi xuống DB thì vòng dưới sẽ đọc lại cờ cũ và bật lại job.
+        await db.systemJob.update({
+          where: { name: options.name },
+          data: { enabled: enabledOverride },
+        });
+        dbJob.enabled = enabledOverride;
+      }
+
+      // DB là nguồn sự thật: admin tắt job thì deploy mới không tự bật lại.
+      if (dbJob.enabled && !job.isRunning()) job.start();
+      else if (!dbJob.enabled && job.isRunning()) job.stop();
+
+      // Lịch trong CODE thắng khi lập trình viên đổi — ghi ngược lại DB.
+      if (dbJob.cronTime !== options.cronTime) {
+        await db.systemJob.update({
+          where: { name: options.name },
+          data: { cronTime: options.cronTime },
+        });
+      }
+    } catch (e) {
+      log().error(`Đồng bộ job ${options.name} với DB lỗi`, e);
+    }
+  }
+
+  private async recordJobRun(
+    name: string,
+    status: string,
+    lastRun?: Date,
+    error?: string,
+  ): Promise<void> {
+    const { db } = requireConfig();
+    if (!db.systemJob) return;
+    try {
+      await db.systemJob.update({
+        where: { name },
+        data: {
+          status,
+          lastRun,
+          error: error ?? null, // chạy được thì xoá lỗi cũ
+          nextRun: this.getJob(name)?.nextDate(),
+        },
+      });
+    } catch (e) {
+      log().error(`Cập nhật trạng thái job ${name} lỗi`, e);
+    }
+  }
+
+  removeJob(name: string): void {
+    const job = this.jobs.get(name);
+    if (!job) return;
+    job.stop();
+    this.jobs.delete(name);
+    this.jobCallbacks.delete(name);
+    this.wrappedCallbacks.delete(name);
+  }
+
+  getJob(name: string): CronJob | undefined {
+    return this.jobs.get(name);
+  }
+
+  getAllJobs(): CronJob[] {
+    return Array.from(this.jobs.values());
+  }
+
+  startAll(): void {
+    this.jobs.forEach((job) => {
+      if (!job.isRunning()) job.start();
+    });
+  }
+
+  stopAll(): void {
+    this.jobs.forEach((job) => job.stop());
+  }
+
+  /** Trạng thái runtime cho trang admin. */
+  getJobsInfo(): Array<{
+    name: string;
+    cronTime: string;
+    isRunning: boolean;
+    nextDate: Date | null;
+  }> {
+    return Array.from(this.jobs.values()).map((job) => ({
+      name: job.name,
+      cronTime: job.cronTime,
+      isRunning: job.isRunning(),
+      nextDate: job.nextDate(),
+    }));
+  }
+
+  async toggleJob(name: string): Promise<boolean> {
+    const job = this.jobs.get(name);
+    if (!job) return false;
+
+    const newState = !job.isRunning();
+    if (newState) job.start();
+    else job.stop();
+
+    const { db } = requireConfig();
+    if (db.systemJob) {
+      try {
+        await db.systemJob.update({
+          where: { name },
+          data: { enabled: newState },
+        });
+      } catch (e) {
+        log().error(`Ghi cờ enabled của job ${name} lỗi`, e);
+      }
+    }
+    return true;
+  }
+
+  /** Chạy tay (fire-and-forget) — vẫn đi qua bản BỌC nên có execution log. */
+  async runJobNow(name: string): Promise<boolean> {
+    const callback = this.wrappedCallbacks.get(name);
+    if (!callback) return false;
+    void Promise.resolve(callback()).catch((e) =>
+      log().error(`Chạy tay job ${name} lỗi`, e),
+    );
+    return true;
+  }
+
+  /** Đổi lịch: dựng lại job từ onTick GỐC, giữ nguyên đường ghi log. */
+  async updateJob(
+    name: string,
+    newCronTime: string,
+    enabled?: boolean,
+  ): Promise<boolean> {
+    const existingJob = this.jobs.get(name);
+    const originalOnTick = this.jobCallbacks.get(name);
+    if (!existingJob || !originalOnTick) {
+      log().warn(`Job ${name} không tồn tại — bỏ qua updateJob`);
+      return false;
+    }
+
+    const wasRunning = existingJob.isRunning();
+    existingJob.stop();
+    this.jobs.delete(name);
+
+    const { db } = requireConfig();
+    let finalEnabled = enabled;
+    if (finalEnabled === undefined && db.systemJob) {
+      try {
+        const dbJob = await db.systemJob.findUnique({ where: { name } });
+        finalEnabled = dbJob?.enabled ?? wasRunning;
+      } catch (e) {
+        log().error(`Đọc trạng thái job ${name} từ DB lỗi`, e);
+        finalEnabled = wasRunning;
+      }
+    }
+
+    const wrappedOnTick = this.wrapOnTick(name, originalOnTick);
+    const newJobOptions: CronJobOptions = {
+      name,
+      cronTime: newCronTime,
+      onTick: wrappedOnTick,
+      start: finalEnabled ?? false,
+    };
+
+    const newJob = new SimpleCronJob(newJobOptions);
+    this.jobs.set(name, newJob);
+    this.jobCallbacks.set(name, originalOnTick);
+    this.wrappedCallbacks.set(name, wrappedOnTick);
+
+    await this.syncJobWithDb(newJobOptions, newJob, enabled);
+    log().info(`Đổi lịch job ${name} → ${newCronTime}`);
+    return true;
+  }
+}
+
+/** Singleton dùng chung app (đăng ký job ở instrumentation). */
+export const cronManager = new DbCronJobManager();

package/src/cron/index.ts

@@ -0,0 +1,24 @@
+export {
+  configureCronManager,
+  cronManager,
+  DbCronJobManager,
+  getJobExecutionContext,
+} from "./db-cron-manager";
+export type {
+  ActionLog,
+  CronDb,
+  CronLogger,
+  JobExecutionContext,
+} from "./db-cron-manager";
+
+// Lớp hẹn giờ thuần RAM — dùng lại khi app không cần trạng thái DB.
+export {
+  cronJobManager,
+  CronJobManagerImpl,
+  SimpleCronJob,
+} from "../infrastructure/cron/cron-manager";
+export type {
+  CronJob,
+  CronJobManager,
+  CronJobOptions,
+} from "../infrastructure/cron/types";

package/src/notification/__tests__/notification-service.test.ts

@@ -0,0 +1,192 @@
+import { beforeEach, describe, expect, it, vi } from "vitest"
+
+import {
+  configureNotificationService,
+  markRead,
+  notify,
+} from "../notification-service"
+import type { NotificationDb, NotifyInput } from "../notification-service"
+
+interface FakeData {
+  rolePermissions: Array<{ resourceCode: string; actionCode: string; roleCode: string }>
+  userRoles: Array<{ roleCode: string; userId: string }>
+  userBranches: Array<{ branchId: string; userId: string; isDefault: boolean }>
+  users: Array<{ id: string; isActive: boolean }>
+}
+
+function makeDb(data: FakeData) {
+  const created: Array<Record<string, unknown>> = []
+  const db = {
+    notification: {
+      createMany: vi.fn(async ({ data: rows }: { data: Array<Record<string, unknown>> }) => {
+        created.push(...rows)
+        return { count: rows.length }
+      }),
+      findMany: vi.fn(async () => []),
+      count: vi.fn(async () => 0),
+      updateMany: vi.fn(async () => ({ count: 1 })),
+    },
+    rolePermission: {
+      findMany: vi.fn(async ({ where }: { where: { resourceCode: string; actionCode: string } }) =>
+        data.rolePermissions
+          .filter(
+            (r) =>
+              r.resourceCode === where.resourceCode &&
+              r.actionCode === where.actionCode,
+          )
+          .map((r) => ({ roleCode: r.roleCode })),
+      ),
+    },
+    userRole: {
+      findMany: vi.fn(async ({ where }: { where: { roleCode: { in: string[] } } }) =>
+        data.userRoles
+          .filter((r) => where.roleCode.in.includes(r.roleCode))
+          .map((r) => ({ userId: r.userId })),
+      ),
+    },
+    userBranch: {
+      findMany: vi.fn(
+        async ({
+          where,
+        }: {
+          where: { branchId: string; userId: { in: string[] }; isDefault?: boolean }
+        }) =>
+          data.userBranches
+            .filter(
+              (b) =>
+                b.branchId === where.branchId &&
+                where.userId.in.includes(b.userId) &&
+                (where.isDefault === undefined || b.isDefault === where.isDefault),
+            )
+            .map((b) => ({ userId: b.userId })),
+      ),
+    },
+    user: {
+      findMany: vi.fn(async ({ where }: { where: { id: { in: string[] } } }) =>
+        data.users
+          .filter((u) => where.id.in.includes(u.id) && u.isActive)
+          .map((u) => ({ id: u.id })),
+      ),
+    },
+  }
+  return { db: db as unknown as NotificationDb, created }
+}
+
+const BASE: FakeData = {
+  rolePermissions: [
+    { resourceCode: "payment-request", actionCode: "approve", roleCode: "MANAGER" },
+  ],
+  userRoles: [
+    { roleCode: "MANAGER", userId: "m1" },
+    { roleCode: "MANAGER", userId: "m2" },
+    { roleCode: "ACCOUNTANT", userId: "a1" },
+  ],
+  userBranches: [
+    { branchId: "b1", userId: "m1", isDefault: true },
+    { branchId: "b1", userId: "m2", isDefault: false },
+  ],
+  users: [
+    { id: "m1", isActive: true },
+    { id: "m2", isActive: true },
+    { id: "a1", isActive: true },
+    { id: "locked", isActive: false },
+    { id: "u1", isActive: true },
+  ],
+}
+
+const INPUT: Omit<NotifyInput, "userIds"> = { title: "T", content: "C" }
+
+describe("notify — resolveRecipients", () => {
+  let created: Array<Record<string, unknown>>
+
+  function setup(
+    data: FakeData = BASE,
+    afterNotify?: (recipients: string[], input: NotifyInput) => Promise<unknown>,
+  ) {
+    const made = makeDb(data)
+    created = made.created
+    configureNotificationService({ db: made.db, afterNotify })
+  }
+
+  beforeEach(() => setup())
+
+  it("userIds tường minh: lọc falsy + user bị khoá, exclude actor", async () => {
+    const n = await notify({
+      ...INPUT,
+      userIds: ["u1", null, undefined, "locked", "m1"],
+      excludeUserId: "m1",
+    })
+    expect(n).toBe(1)
+    expect(created.map((c) => c.userId)).toEqual(["u1"])
+  })
+
+  it("roleCodes + branchId (member): chỉ user được gán chi nhánh", async () => {
+    const n = await notify({ ...INPUT, roleCodes: ["MANAGER"], branchId: "b1" })
+    expect(n).toBe(2) // m1 + m2 đều thuộc b1
+  })
+
+  it("branchScope default: chỉ user có isDefault tại chi nhánh", async () => {
+    const n = await notify({
+      ...INPUT,
+      roleCodes: ["MANAGER"],
+      branchId: "b1",
+      branchScope: "default",
+    })
+    expect(n).toBe(1)
+    expect(created[0].userId).toBe("m1")
+  })
+
+  it("permission → suy ra roleCodes từ rolePermission", async () => {
+    const n = await notify({
+      ...INPUT,
+      permission: { resourceCode: "payment-request", actionCode: "approve" },
+    })
+    expect(n).toBe(2) // MANAGER: m1, m2
+  })
+
+  it("roleCodesAllBranches bỏ qua lọc chi nhánh + gộp distinct", async () => {
+    const n = await notify({
+      ...INPUT,
+      roleCodes: ["MANAGER"],
+      branchId: "b1",
+      branchScope: "default", // member lọc còn m1
+      roleCodesAllBranches: ["ACCOUNTANT"], // a1 vào bất kể CN
+    })
+    expect(n).toBe(2)
+    expect(created.map((c) => c.userId).sort()).toEqual(["a1", "m1"])
+  })
+
+  it("afterNotify được gọi với recipients sau khi ghi DB", async () => {
+    const after = vi.fn(async () => {})
+    setup(BASE, after)
+    await notify({ ...INPUT, userIds: ["u1"] })
+    await new Promise((r) => setTimeout(r, 5))
+    expect(after).toHaveBeenCalledWith(["u1"], expect.objectContaining({ title: "T" }))
+  })
+
+  it("không người nhận → 0 row, afterNotify KHÔNG gọi", async () => {
+    const after = vi.fn(async () => {})
+    setup(BASE, after)
+    const n = await notify({ ...INPUT, userIds: ["locked"] })
+    expect(n).toBe(0)
+    expect(after).not.toHaveBeenCalled()
+  })
+
+  it("db nổ → notify nuốt lỗi trả 0 (KHÔNG throw — không chặn nghiệp vụ)", async () => {
+    const made = makeDb(BASE)
+    ;(made.db.notification.createMany as ReturnType<typeof vi.fn>).mockRejectedValue(
+      new Error("db down"),
+    )
+    configureNotificationService({ db: made.db })
+    await expect(notify({ ...INPUT, userIds: ["u1"] })).resolves.toBe(0)
+  })
+})
+
+describe("markRead", () => {
+  it("ids rỗng → 0, không đụng db", async () => {
+    const made = makeDb(BASE)
+    configureNotificationService({ db: made.db })
+    expect(await markRead("u1", [])).toBe(0)
+    expect(made.db.notification.updateMany).not.toHaveBeenCalled()
+  })
+})