@goplusvn/core 0.1.86 → 0.1.88

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@goplusvn/core",
   "description": "GoPlusVN Platform Kit - ERP kernel: layout, RBAC, CRUD, multi-tenant, system pages",
-  "version": "0.1.86",
+  "version": "0.1.88",
   "private": false,
   "publishConfig": {
     "registry": "https://registry.npmjs.org",

package/src/audit/__tests__/prisma-audit-extension.test.ts

@@ -194,6 +194,119 @@ describe("createAuditExtension", () => {
     });
   });
 
+  // ── Khoá chính KIỂU SỐ ────────────────────────────────────────────────
+  // Bảng nghiệp vụ (meal_orders, employees, menus…) dùng serial, không cuid.
+  // Trước bản này `resourceId.slice()` ném TypeError, `catch` ngoài cùng nuốt
+  // gọn, và audit của TẤT CẢ các bảng đó không bao giờ được ghi — không ai
+  // biết vì nghiệp vụ vẫn chạy bình thường.
+  describe("khoá chính kiểu số", () => {
+    it("create trên bảng khoá số VẪN ghi audit, id thành chuỗi", async () => {
+      const query = vi
+        .fn()
+        .mockResolvedValue({ id: 1234567890, name: "Cơm sườn" });
+
+      await handler({
+        model: "SalesOrder",
+        operation: "create",
+        args: { data: { name: "Cơm sườn" } },
+        query,
+      });
+      await settle();
+
+      expect(rawClient.auditLog.create).toHaveBeenCalledWith({
+        data: expect.objectContaining({
+          action: "create",
+          resource: "sales-order",
+          resourceId: "1234567890",
+        }),
+      });
+    });
+
+    it("update tra dữ liệu cũ bằng id SỐ, không ép thành chuỗi", async () => {
+      rawClient.salesOrder.findUnique.mockResolvedValue({
+        id: 42,
+        name: "Tên cũ",
+      });
+      const query = vi.fn().mockResolvedValue({ id: 42 });
+
+      await handler({
+        model: "SalesOrder",
+        operation: "update",
+        args: { where: { id: 42 }, data: { name: "Tên mới" } },
+        query,
+      });
+      await settle();
+
+      // Ép chuỗi ở bước tra cứu là Prisma từ chối ngay: cột Int không nhận "42".
+      expect(rawClient.salesOrder.findUnique).toHaveBeenCalledWith({
+        where: { id: 42 },
+      });
+      expect(rawClient.auditLog.create).toHaveBeenCalledWith({
+        data: expect.objectContaining({
+          action: "update",
+          resourceId: "42",
+          oldData: expect.objectContaining({ name: "Tên cũ" }),
+          newData: expect.objectContaining({ name: "Tên mới" }),
+        }),
+      });
+    });
+
+    it("mô tả có đuôi #id thay vì làm vỡ cả dòng audit", async () => {
+      const query = vi.fn().mockResolvedValue({ id: 987654321, name: "X" });
+
+      await handler({
+        model: "SalesOrder",
+        operation: "create",
+        args: { data: { name: "X" } },
+        query,
+      });
+      await settle();
+
+      const arg = rawClient.auditLog.create.mock.calls[0]?.[0];
+      expect(arg.data.description).toContain("#87654321");
+    });
+
+    it("xoá-theo-điều-kiện trên bảng khoá số cũng ghi được", async () => {
+      rawClient.salesOrder.findFirst.mockResolvedValue({
+        id: 7,
+        code: "SO007",
+      });
+      const query = vi.fn().mockResolvedValue({ id: 7 });
+
+      await handler({
+        model: "SalesOrder",
+        operation: "delete",
+        args: { where: { code: "SO007" } },
+        query,
+      });
+      await settle();
+
+      expect(rawClient.auditLog.create).toHaveBeenCalledWith({
+        data: expect.objectContaining({
+          action: "delete",
+          resourceId: "7",
+          oldData: expect.objectContaining({ code: "SO007" }),
+        }),
+      });
+    });
+
+    it("id = 0 vẫn là id hợp lệ, không bị coi là 'không có'", async () => {
+      const query = vi.fn().mockResolvedValue({ id: 0, name: "Gốc" });
+
+      await handler({
+        model: "SalesOrder",
+        operation: "create",
+        args: { data: { name: "Gốc" } },
+        query,
+      });
+      await settle();
+
+      expect(rawClient.auditLog.create).toHaveBeenCalledWith({
+        data: expect.objectContaining({ resourceId: "0" }),
+      });
+    });
+  });
+
   it("PascalCase → kebab-case khớp mã resource RBAC", async () => {
     const query = vi.fn().mockResolvedValue({ id: "so-1" });
     await handler({

package/src/audit/prisma-audit-extension.ts

@@ -99,11 +99,34 @@ function toResourceName(modelName: string): string {
 }
 
 /** Lấy id từ where khi có — đường nhanh; không có thì fallback findFirst(where). */
-function extractId(where: Record<string, any> | undefined): string | null {
-  if (!where?.id) return null;
-  if (typeof where.id === "string") return where.id;
-  if (typeof where.id === "object" && where.id?.equals)
-    return String(where.id.equals);
+function extractId(
+  where: Record<string, any> | undefined,
+): string | number | null {
+  const id = where?.id;
+  if (id === undefined || id === null || id === "") return null;
+  // Khoá chính KHÔNG chỉ là cuid: bảng nghiệp vụ (meal_orders, employees…)
+  // dùng serial nên `where.id` là số. Trả về GIÁ TRỊ GỐC, không ép chuỗi ở
+  // đây — `findUnique({ where: { id: "123" } })` trên cột Int là lỗi kiểu.
+  if (typeof id === "string" || typeof id === "number") return id;
+  if (typeof id === "bigint") return Number(id);
+  if (typeof id === "object" && id.equals !== undefined && id.equals !== null) {
+    const eq = id.equals;
+    if (typeof eq === "string" || typeof eq === "number") return eq;
+    if (typeof eq === "bigint") return Number(eq);
+  }
+  return null;
+}
+
+/**
+ * Cột `resource_id` của bảng audit là CHUỖI, còn khoá chính có thể là số.
+ * Mọi id phải đi qua đây trước khi vào audit — trước đây thiếu bước này nên
+ * `resourceId.slice()` ném `TypeError` trên mọi bảng khoá số, lỗi bị nuốt ở
+ * `catch` ngoài cùng và audit log của các bảng đó IM LẶNG không bao giờ ghi.
+ */
+function toResourceId(id: unknown): string | null {
+  if (id === null || id === undefined || id === "") return null;
+  if (typeof id === "string") return id;
+  if (typeof id === "number" || typeof id === "bigint") return String(id);
   return null;
 }
 
@@ -246,7 +269,7 @@ export function createAuditExtension(options: CreateAuditExtensionOptions) {
           // xoá-theo-code hay sửa-theo-email vẫn để lại dấu vết.
           let oldData: Record<string, unknown> | null = null;
           let oldRows: Array<Record<string, unknown>> | null = null;
-          let resourceId: string | null = null;
+          let resourceIdRaw: string | number | null = null;
 
           const isMutationByWhere = action === "update" || action === "delete";
 
@@ -271,16 +294,18 @@ export function createAuditExtension(options: CreateAuditExtensionOptions) {
                 /* nuốt — audit không được làm vỡ nghiệp vụ */
               }
             } else {
-              resourceId = extractId(where);
+              resourceIdRaw = extractId(where);
               try {
                 let existing: any = null;
-                if (resourceId && delegate?.findUnique) {
+                if (resourceIdRaw !== null && delegate?.findUnique) {
                   existing = await delegate.findUnique({
-                    where: { id: resourceId },
+                    where: { id: resourceIdRaw },
                   });
                 } else if (delegate?.findFirst) {
                   existing = await delegate.findFirst({ where });
-                  if (existing?.id) resourceId = existing.id;
+                  if (existing?.id !== undefined && existing?.id !== null) {
+                    resourceIdRaw = existing.id;
+                  }
                 }
                 if (existing) oldData = sanitizeData(existing);
               } catch {
@@ -436,13 +461,14 @@ export function createAuditExtension(options: CreateAuditExtensionOptions) {
             // Đường một dòng
             let newData: Record<string, unknown> | null = null;
             if (action === "create" && result) {
-              resourceId = (result as any)?.id || null;
+              resourceIdRaw = (result as any)?.id ?? null;
               newData = sanitizeData(result);
             } else if (action === "update") {
               newData = sanitizeData((args as any)?.data);
             }
 
             const userName = actor?.userName || "Hệ thống";
+            const resourceId = toResourceId(resourceIdRaw);
             const description = buildDescription(
               action,
               resource,
@@ -487,7 +513,7 @@ export function buildDescription(
   userName: string,
   oldData?: Record<string, unknown> | null,
   newData?: Record<string, unknown> | null,
-  resourceId?: string | null,
+  resourceId?: string | number | null,
 ): string {
   const actionLabels: Record<string, string> = {
     create: "Tạo mới",
@@ -551,7 +577,9 @@ export function buildDescription(
     ]);
   }
 
-  const idSuffix = resourceId ? ` #${resourceId.slice(-8)}` : "";
+  // `String(...)` là chốt chặn: dù đường nào lọt một khoá số xuống tới đây,
+  // mô tả vẫn dựng được thay vì ném lỗi và mất trắng dòng audit.
+  const idSuffix = resourceId ? ` #${String(resourceId).slice(-8)}` : "";
   return `[${userName}] ${actionLabel} ${resource}${idSuffix}${changeSummary}`;
 }
 

package/src/configs/status.ts

@@ -23,3 +23,70 @@ export function booleanToStatus(value: boolean): string {
 export function statusToBoolean(value: string): boolean {
   return value === STATUS_ACTIVE;
 }
+
+/**
+ * CHUẨN HOÁ GIÁ TRỊ TRẠNG THÁI — một chỗ duy nhất cho cả app.
+ *
+ * Cùng một ô "Trạng thái" trên màn hình CRUD, dữ liệu về từ DB có thể là:
+ *
+ *   - chuỗi  `"active"` / `"inactive"`  (cột text — kiểu hay dùng nhất)
+ *   - boolean `true` / `false`          (cột Boolean: `is_active`, `enabled`…)
+ *   - số     `1` / `0`                  (cột smallint, hoặc Prisma trả BigInt)
+ *   - chuỗi  `"true"` / `"1"`           (giá trị đi qua query string / form)
+ *
+ * Trước đây mỗi nơi tự đoán: bảng thì so `optValue === value` (so tuyệt đối
+ * nên `true` không khớp option `"active"` ⇒ chip hiện chữ "true"), form thì
+ * so cứng `value === "active"` (nên bản ghi boolean `true` hiện công tắc TẮT).
+ * Hàm này là mẫu số chung: đưa mọi biến thể về MỘT key chuỗi rồi mới so.
+ *
+ * Trả `null` khi bỏ trống, và trả nguyên key với những trạng thái KHÔNG phải
+ * bật/tắt (`"pending"`, `"cancelled"`…) để bảng màu trạng thái vẫn tra được.
+ */
+export function normalizeStatusValue(value: unknown): string | null {
+  if (value === null || value === undefined) return null;
+  if (typeof value === "boolean") {
+    return value ? STATUS_ACTIVE : STATUS_INACTIVE;
+  }
+  if (typeof value === "number" || typeof value === "bigint") {
+    return Number(value) !== 0 ? STATUS_ACTIVE : STATUS_INACTIVE;
+  }
+  if (typeof value !== "string") return null;
+
+  const key = value.trim().toLowerCase().replace(/\s+/g, "_");
+  if (key === "") return null;
+  if (["true", "1", "on", "yes", "y", "enabled"].includes(key)) {
+    return STATUS_ACTIVE;
+  }
+  if (["false", "0", "off", "no", "n", "disabled"].includes(key)) {
+    return STATUS_INACTIVE;
+  }
+  return key;
+}
+
+/** Giá trị này có nghĩa là "đang bật" không? Dùng cho công tắc ở form. */
+export function isTruthyStatus(value: unknown): boolean {
+  return normalizeStatusValue(value) === STATUS_ACTIVE;
+}
+
+/**
+ * Giá trị của một dòng dữ liệu có khớp với `option` đã khai trong FieldConfig
+ * không — SO LỎNG, theo ba nấc:
+ *
+ *   1. bằng tuyệt đối (đường nhanh, giữ nguyên hành vi cũ);
+ *   2. bằng sau khi đổi ra chuỗi (`1` khớp `"1"`);
+ *   3. bằng sau khi chuẩn hoá trạng thái (`true` khớp `"active"`).
+ *
+ * Nấc 3 chỉ nhận khi CẢ HAI vế chuẩn hoá được — nếu không, hai giá trị lạ
+ * cùng ra `null` sẽ khớp bừa với nhau.
+ */
+export function matchesOptionValue(
+  optionValue: unknown,
+  value: unknown,
+): boolean {
+  if (optionValue === value) return true;
+  if (value === null || value === undefined) return false;
+  if (String(optionValue) === String(value)) return true;
+  const a = normalizeStatusValue(optionValue);
+  const b = normalizeStatusValue(value);
+  return a !== null && a === b;
+}

package/src/cron/__tests__/cron-single-runner.test.ts

@@ -0,0 +1,260 @@
+/**
+ * HỒI QUY — hai lỗi cron đã gây hậu quả thật trên prod:
+ *
+ *  1. MỌI job chạy HAI LẦN mỗi nhịp vì có hai tiến trình cùng đăng ký cron
+ *     (`job_execution_logs` có 2 dòng cùng `started_at` cho mỗi nhịp). Job
+ *     chốt ngày chạy lượt thứ hai ghi đè kết quả của lượt đầu.
+ *  2. Job hằng ngày nổ LỆCH 7 TIẾNG vì một tiến trình chạy TZ=UTC trong khi
+ *     lịch được hiểu theo giờ địa phương của tiến trình — "30 22 * * *" nổ
+ *     lúc 05:30 sáng VN và chốt "không đi làm" cho cả nhà máy.
+ *
+ * Chốt lần lượt: (1) giành lượt chạy bằng UPDATE có điều kiện trên
+ * `system_jobs`; (2) khai `timezone` cho job thì lịch bám múi giờ nghiệp vụ
+ * chứ không bám cấu hình máy.
+ */
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { configureCronManager, DbCronJobManager } from "../db-cron-manager";
+import type { CronDb } from "../db-cron-manager";
+import {
+  nextCronDate,
+  parseCronExpression,
+  zonedParts,
+} from "../cron-schedule";
+
+interface JobRow {
+  name: string;
+  cronTime: string;
+  enabled: boolean;
+  status?: string;
+  lastRun?: Date | null;
+  nextRun?: Date | null;
+  error?: string | null;
+}
+
+/**
+ * Fake Prisma CÓ `updateMany` với đúng ngữ nghĩa UPDATE có điều kiện —
+ * đây chính là chỗ khoá: chỉ dòng nào còn thoả điều kiện mới bị ghi.
+ */
+function makeSharedDb() {
+  const jobs = new Map<string, JobRow>();
+  const logs: Array<{ id: string; jobName: string; status: string }> = [];
+  let seq = 0;
+
+  const db = {
+    systemJob: {
+      count: vi.fn(async () => jobs.size),
+      findUnique: vi.fn(
+        async ({ where }: { where: { name: string } }) =>
+          jobs.get(where.name) ?? null,
+      ),
+      create: vi.fn(async ({ data }: { data: JobRow }) => {
+        jobs.set(data.name, { ...data });
+        return jobs.get(data.name);
+      }),
+      update: vi.fn(
+        async ({
+          where,
+          data,
+        }: {
+          where: { name: string };
+          data: Partial<JobRow>;
+        }) => {
+          const row = jobs.get(where.name);
+          if (!row) throw new Error(`no job ${where.name}`);
+          Object.assign(row, data);
+          return row;
+        },
+      ),
+      updateMany: vi.fn(
+        async ({
+          where,
+          data,
+        }: {
+          where: {
+            name: string;
+            OR: Array<{ lastRun: null | { lt: Date } }>;
+          };
+          data: Partial<JobRow>;
+        }) => {
+          const row = jobs.get(where.name);
+          if (!row) return { count: 0 };
+          const floor = where.OR.find((c) => c.lastRun !== null)?.lastRun as
+            | { lt: Date }
+            | undefined;
+          const ok =
+            row.lastRun == null ||
+            (floor ? row.lastRun.getTime() < floor.lt.getTime() : false);
+          if (!ok) return { count: 0 };
+          Object.assign(row, data);
+          return { count: 1 };
+        },
+      ),
+    },
+    jobExecutionLog: {
+      create: vi.fn(
+        async ({ data }: { data: { jobName: string; status: string } }) => {
+          const row = { id: `log${++seq}`, ...data };
+          logs.push(row);
+          return row;
+        },
+      ),
+      update: vi.fn(async () => ({})),
+    },
+  };
+
+  return { db: db as unknown as CronDb, jobs, logs };
+}
+
+const silentLogger = { info: vi.fn(), warn: vi.fn(), error: vi.fn() };
+
+describe("giành lượt chạy — hai tiến trình, một lượt", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date("2026-08-23T03:00:00.000Z"));
+    delete process.env.GOERP_CRON_SINGLE_RUNNER;
+  });
+  afterEach(() => {
+    vi.useRealTimers();
+    delete process.env.GOERP_CRON_SINGLE_RUNNER;
+  });
+
+  it("hai manager cùng DB, cùng nhịp → onTick chỉ chạy MỘT lần", async () => {
+    const { db, logs } = makeSharedDb();
+    configureCronManager({ db, logger: silentLogger });
+
+    const tick = vi.fn();
+    const a = new DbCronJobManager();
+    const b = new DbCronJobManager();
+    a.addJob({ name: "close-day", cronTime: "1s", onTick: tick, start: true });
+    b.addJob({ name: "close-day", cronTime: "1s", onTick: tick, start: true });
+    await vi.advanceTimersByTimeAsync(0);
+
+    await vi.advanceTimersByTimeAsync(1100);
+    a.stopAll();
+    b.stopAll();
+
+    expect(tick).toHaveBeenCalledTimes(1);
+    // Tiến trình bị loại KHÔNG được để lại execution log — nếu không thì màn
+    // hình lịch sử vẫn hiện hai dòng mỗi nhịp như trước.
+    expect(logs.filter((l) => l.jobName === "close-day")).toHaveLength(1);
+  });
+
+  it("nhịp SAU vẫn chạy (khoá theo nhịp, không khoá vĩnh viễn)", async () => {
+    const { db } = makeSharedDb();
+    configureCronManager({ db, logger: silentLogger });
+
+    const tick = vi.fn();
+    const a = new DbCronJobManager();
+    a.addJob({ name: "reconcile", cronTime: "1s", onTick: tick, start: true });
+    await vi.advanceTimersByTimeAsync(0);
+
+    await vi.advanceTimersByTimeAsync(1100);
+    // Nhịp kế tiếp phải rơi sang PHÚT khác thì mốc nhịp mới đổi.
+    vi.setSystemTime(new Date("2026-08-23T03:02:00.000Z"));
+    await vi.advanceTimersByTimeAsync(1100);
+    a.stopAll();
+
+    expect(tick).toHaveBeenCalledTimes(2);
+  });
+
+  it("GOERP_CRON_SINGLE_RUNNER=off → giữ hành vi cũ (chạy cả hai)", async () => {
+    process.env.GOERP_CRON_SINGLE_RUNNER = "off";
+    const { db } = makeSharedDb();
+    configureCronManager({ db, logger: silentLogger });
+
+    const tick = vi.fn();
+    const a = new DbCronJobManager();
+    const b = new DbCronJobManager();
+    a.addJob({ name: "sms", cronTime: "1s", onTick: tick, start: true });
+    b.addJob({ name: "sms", cronTime: "1s", onTick: tick, start: true });
+    await vi.advanceTimersByTimeAsync(0);
+
+    await vi.advanceTimersByTimeAsync(1100);
+    a.stopAll();
+    b.stopAll();
+
+    expect(tick).toHaveBeenCalledTimes(2);
+  });
+
+  it('nút "Chạy ngay" KHÔNG bị chặn dù nhịp đã có người nhận', async () => {
+    const { db } = makeSharedDb();
+    configureCronManager({ db, logger: silentLogger });
+
+    const tick = vi.fn();
+    const a = new DbCronJobManager();
+    a.addJob({ name: "menu-sync", cronTime: "1s", onTick: tick, start: true });
+    await vi.advanceTimersByTimeAsync(0);
+    await vi.advanceTimersByTimeAsync(1100);
+    expect(tick).toHaveBeenCalledTimes(1);
+
+    await a.runJobNow("menu-sync");
+    await vi.advanceTimersByTimeAsync(0);
+    a.stopAll();
+
+    expect(tick).toHaveBeenCalledTimes(2);
+  });
+});
+
+describe("lịch bám MÚI GIỜ NGHIỆP VỤ, không bám cấu hình máy", () => {
+  const at = (iso: string) => new Date(iso);
+
+  it("zonedParts đọc đúng giờ VN từ một mốc UTC", () => {
+    const p = zonedParts(at("2026-08-23T15:30:00.000Z"), "Asia/Ho_Chi_Minh");
+    expect(p).toMatchObject({ hour: 22, minute: 30, dayOfMonth: 23, month: 8 });
+  });
+
+  it("CÙNG một lịch, hai múi giờ khác nhau → hai mốc chạy khác nhau", () => {
+    // Phép thử KHÔNG phụ thuộc múi giờ của máy chạy test: cùng biểu thức
+    // "30 22 * * *", đọc theo UTC và theo giờ VN phải lệch nhau đúng 7 tiếng.
+    // Bản cũ bỏ qua tham số múi giờ nên hai kết quả TRÙNG NHAU — đúng cái làm
+    // container UTC nổ job chốt ngày lúc 05:30 sáng VN.
+    const fields = parseCronExpression("30 22 * * *")!;
+    const from = at("2026-08-23T00:00:00.000Z");
+    const inUtc = nextCronDate(fields, from, "UTC")!;
+    const inVn = nextCronDate(fields, from, "Asia/Ho_Chi_Minh")!;
+    expect(inUtc.toISOString()).toBe("2026-08-23T22:30:00.000Z");
+    expect(inVn.toISOString()).toBe("2026-08-23T15:30:00.000Z");
+    expect(inUtc.getTime() - inVn.getTime()).toBe(7 * 60 * 60 * 1000);
+  });
+
+  it('"30 22 * * *" + timezone VN → 15:30 UTC, dù máy chạy múi nào', () => {
+    const fields = parseCronExpression("30 22 * * *")!;
+    const next = nextCronDate(
+      fields,
+      at("2026-08-23T00:00:00.000Z"),
+      "Asia/Ho_Chi_Minh",
+    );
+    expect(next?.toISOString()).toBe("2026-08-23T15:30:00.000Z");
+  });
+
+  it("qua nửa đêm giờ VN thì nhảy sang NGÀY HÔM SAU đúng", () => {
+    const fields = parseCronExpression("0 23 * * *")!;
+    // 17:00Z = 00:00 hôm sau giờ VN ⇒ lần chạy kế là 23:00 VN của ngày 24.
+    const next = nextCronDate(
+      fields,
+      at("2026-08-23T17:00:00.000Z"),
+      "Asia/Ho_Chi_Minh",
+    );
+    expect(next?.toISOString()).toBe("2026-08-24T16:00:00.000Z");
+  });
+
+  it("thứ trong tuần cũng đọc theo múi giờ nghiệp vụ", () => {
+    // 2026-08-23 17:00Z là Chủ nhật ở UTC nhưng đã là THỨ HAI 00:00 giờ VN.
+    const fields = parseCronExpression("0 8 * * 1")!;
+    const next = nextCronDate(
+      fields,
+      at("2026-08-23T17:00:00.000Z"),
+      "Asia/Ho_Chi_Minh",
+    );
+    expect(next?.toISOString()).toBe("2026-08-24T01:00:00.000Z");
+  });
+
+  it("không khai timezone → giữ nguyên hành vi cũ (giờ máy)", () => {
+    const fields = parseCronExpression("*/10 * * * *")!;
+    const from = at("2026-08-23T03:03:00.000Z");
+    const next = nextCronDate(fields, from);
+    expect(next!.getMinutes() % 10).toBe(0);
+    expect(next!.getTime()).toBeGreaterThan(from.getTime());
+  });
+});