@goplusvn/core 0.1.89 → 0.1.90

package/CHANGELOG.md

@@ -1,3 +1,31 @@
+## 0.1.90 — `between` phủ hết ngày cuối, và một bảng toán tử duy nhất
+
+Tiếp bản 0.1.89. `buildListQuery` **chép lại** bảng toán tử thay vì gọi
+`conditionForOperator` — và bản chép thiếu `between`. Hệ quả nối nhau:
+
+- Trước 0.1.89: mảng `[từ, đến]` rơi xuống nhánh mặc định rồi đi thẳng vào
+  Prisma dạng array ⇒ nổ ở tầng driver. Bộ lọc khoảng ngày của app khai đúng
+  `type: "datetime"` + `operator: "between"` hỏng sẵn mà không ai báo.
+- 0.1.89 thêm `between` nhưng dịch cận trên thành `lte`: bộ chọn ngày chỉ chở
+  ngày trần, `lte: 31/08` là chặn ở **00:00** ngày cuối ⇒ ngày cuối bị cắt gần
+  hết. Chọn 01/08–31/08 thì đơn tạo lúc 9h sáng 31/08 rơi ra ngoài. Không có
+  exception nào, chỉ thiếu dữ liệu — khó phát hiện hơn hẳn lỗi ở trên.
+
+**Đổi**
+
+- `crud/lib/filter-tree.ts` — `conditionForOperator` thêm `case "between"`,
+  dựng khoảng **nửa mở** `[từ, đến+1 ngày)` khi cận trên là ngày trần (chuỗi
+  `YYYY-MM-DD`, hoặc `Date` đúng nửa đêm UTC do `coerceFieldValue` sinh ra).
+  Mốc có giờ thật giữ nguyên `lte`; khoảng số vẫn là khoảng đóng.
+  KHÔNG cộng offset múi giờ ở đây — cận dưới cũng đang hiểu theo nửa đêm UTC,
+  thêm offset vào một đầu thì hai đầu lệch nhau. App cần biên theo lịch địa
+  phương thì quy đổi trước khi gửi.
+- `crud/lib/query-builder.ts` — bỏ chuỗi `if/else` chép tay, gọi thẳng
+  `conditionForOperator`. Filter phẳng và `filterTree` từ nay không thể lệch
+  bảng toán tử nữa (có test đối chiếu từng toán tử giữa hai đường).
+
+**Quy tắc rút ra**: comment ghi "dùng chung" mà code vẫn chép tay thì chỗ chép
+sẽ tụt lại — hợp nhất thật, đừng ghi chú suông.
 ## 0.1.89 — Bộ lọc CRUD: `defaultValue` sống lại, chip vẽ một lần và đọc được
 
 Trang danh sách theo ngày (nghỉ phép, tăng ca, đăng ký suất ăn) mở ra là nạp

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.89",
+  "version": "0.1.90",
   "private": false,
   "publishConfig": {
     "registry": "https://registry.npmjs.org",

package/src/crud/lib/filter-between.test.ts

@@ -0,0 +1,123 @@
+/**
+ * BỘ LỌC KHOẢNG NGÀY — `between`.
+ *
+ * Hai lỗi nối nhau, cùng một gốc: `buildListQuery` chép lại bảng toán tử thay
+ * vì gọi `conditionForOperator`, và bản chép thiếu `between`.
+ *
+ *  1. Trước 0.1.89: mảng `[từ, đến]` rơi xuống nhánh mặc định, đi thẳng vào
+ *     Prisma dạng array ⇒ nổ ở tầng driver. Hai bộ lọc khoảng ngày của vinhhoa
+ *     (orders.createdAt, purchaseOrders.orderDate) hỏng sẵn mà không ai báo.
+ *  2. 0.1.89 dịch thành `lte` ⇒ chặn ở 00:00 ngày cuối, NGÀY CUỐI BỊ CẮT gần
+ *     hết. Đây mới là kiểu hỏng nguy hiểm: không exception, chỉ thiếu dữ liệu.
+ *
+ * Bản vá: khoảng nửa mở `[từ, đến+1 ngày)`, và hai đường (filter phẳng /
+ * `filterTree`) dùng CHUNG một bảng toán tử để không lệch nhau lần nữa.
+ */
+import { describe, expect, it } from "vitest";
+
+import type { EntityConfig, FilterOperator } from "../../types";
+
+import { buildListQuery } from "./query-builder";
+import { conditionForOperator } from "./filter-tree";
+
+const config = {
+  name: "orders",
+  label: "Đơn",
+  pluralLabel: "Đơn",
+  fields: [
+    { name: "createdAt", label: "Ngày tạo", type: "datetime" },
+    { name: "total", label: "Tổng", type: "number" },
+  ],
+} as unknown as EntityConfig;
+
+function whereFor(value: unknown) {
+  return buildListQuery({
+    entity: "orders",
+    config,
+    params: {
+      page: 1,
+      pageSize: 10,
+      filters: [{ name: "createdAt", value, operator: "between" }],
+    },
+  }).where.createdAt;
+}
+
+describe("between — cận trên phải phủ hết ngày cuối", () => {
+  it("ngày trần dạng chuỗi ➝ nửa mở tới nửa đêm hôm sau", () => {
+    expect(whereFor(["2026-08-01", "2026-08-31"])).toEqual({
+      gte: "2026-08-01",
+      lt: new Date("2026-09-01T00:00:00.000Z"),
+    });
+  });
+
+  it("Date nửa đêm UTC (đã qua coerceFieldValue) cũng được nới", () => {
+    const where = whereFor([
+      new Date("2026-08-01T00:00:00.000Z"),
+      new Date("2026-08-31T00:00:00.000Z"),
+    ]);
+
+    expect((where as { lt: Date }).lt.toISOString()).toBe(
+      "2026-09-01T00:00:00.000Z",
+    );
+  });
+
+  it("bản ghi lúc 9h sáng ngày cuối nằm TRONG khoảng", () => {
+    const { lt } = whereFor(["2026-08-01", "2026-08-31"]) as { lt: Date };
+    expect(new Date("2026-08-31T09:00:00.000Z").getTime()).toBeLessThan(
+      lt.getTime(),
+    );
+  });
+
+  it("mốc CÓ giờ thật thì giữ nguyên lte, không tự nới thêm một ngày", () => {
+    const end = new Date("2026-08-31T12:30:00.000Z");
+    expect(whereFor(["2026-08-01T00:00:00.000Z", end])).toEqual({
+      gte: "2026-08-01T00:00:00.000Z",
+      lte: end,
+    });
+  });
+
+  it("mảng không đủ hai mốc ➝ trả nguyên giá trị, không dựng khoảng méo", () => {
+    expect(conditionForOperator("between", ["2026-08-01"])).toEqual([
+      "2026-08-01",
+    ]);
+  });
+
+  it("khoảng số vẫn là khoảng đóng — chỉ NGÀY mới được nới", () => {
+    expect(conditionForOperator("between", [1000, 5000])).toEqual({
+      gte: 1000,
+      lte: 5000,
+    });
+  });
+});
+
+describe("filter phẳng và filterTree dùng chung một bảng toán tử", () => {
+  const cases: [FilterOperator, unknown][] = [
+    ["contains", "an"],
+    ["in", [1, 2]],
+    ["notIn", [3]],
+    ["eq", 5],
+    ["ne", 5],
+    ["gt", 5],
+    ["gte", 5],
+    ["lt", 5],
+    ["lte", 5],
+    ["startsWith", "a"],
+    ["endsWith", "z"],
+    ["isNotNull", 1],
+    ["between", ["2026-08-01", "2026-08-31"]],
+  ];
+
+  it.each(cases)("%s cho cùng một điều kiện ở cả hai đường", (op, value) => {
+    const flat = buildListQuery({
+      entity: "orders",
+      config,
+      params: {
+        page: 1,
+        pageSize: 10,
+        filters: [{ name: "total", value, operator: op }],
+      },
+    }).where.total;
+
+    expect(flat).toEqual(conditionForOperator(op, value));
+  });
+});

package/src/crud/lib/filter-tree.ts

@@ -29,11 +29,46 @@ export type FilterTreeNode =
 const MAX_DEPTH = 4;
 const MAX_LEAVES = 30;
 
+const DATE_KEY = /^\d{4}-\d{2}-\d{2}$/;
+const DAY_MS = 86_400_000;
+
+/**
+ * Cận TRÊN của `between` khi mốc gửi xuống không mang giờ.
+ *
+ * Bộ chọn ngày chỉ chở ngày trần ("2026-08-31", hoặc `Date` đã ép về nửa đêm
+ * UTC — xem `coerceFieldValue`). Dịch thẳng thành `lte` là chặn ở 00:00 của
+ * ngày cuối, tức NGÀY CUỐI BỊ CẮT gần hết: chọn 01/08–31/08 thì bản ghi tạo
+ * lúc 9h sáng 31/08 rơi ra ngoài. Người dùng không thấy lỗi, chỉ thấy thiếu
+ * dữ liệu — kiểu hỏng khó phát hiện hơn hẳn một cái exception.
+ *
+ * Nên khoảng dựng NỬA MỞ: `[từ, đến+1 ngày)`. Không cộng múi giờ ở đây —
+ * cận dưới cũng đang hiểu theo nửa đêm UTC, thêm offset vào một đầu thì hai
+ * đầu lệch nhau. App nào cần biên theo lịch địa phương thì tự quy đổi trước
+ * khi gửi (xem cách tanloc-spartronics dùng `vnDateKeyToDbDate`).
+ *
+ * Mốc CÓ giờ thật thì giữ nguyên `lte` — đó là ý người gọi, không phải ngày trần.
+ */
+function upperDateBound(value: unknown): Record<string, unknown> {
+  if (typeof value === "string" && DATE_KEY.test(value)) {
+    return { lt: new Date(Date.parse(`${value}T00:00:00.000Z`) + DAY_MS) };
+  }
+  // Nửa đêm UTC chằn chặn = ngày trần đã qua `new Date("YYYY-MM-DD")`.
+  if (value instanceof Date && value.getTime() % DAY_MS === 0) {
+    return { lt: new Date(value.getTime() + DAY_MS) };
+  }
+  return { lte: value };
+}
+
 /** Điều kiện Prisma cho một toán tử — dùng chung với filter phẳng. */
 export function conditionForOperator(op: string, value: unknown): unknown {
   switch (op) {
     case "contains":
       return { contains: value, mode: "insensitive" };
+    // Khoảng [từ, đến] của bộ chọn ngày. Trước 0.1.89 KHÔNG có nhánh này: cả
+    // mảng rơi xuống `default` và đi thẳng vào Prisma dạng array ⇒ nổ ở driver.
+    case "between":
+      if (!Array.isArray(value) || value.length !== 2) return value;
+      return { gte: value[0], ...upperDateBound(value[1]) };
     case "in":
       return { in: value };
     case "notIn":

package/src/crud/lib/query-builder.ts

@@ -1,4 +1,4 @@
-import { compileFilterTree } from "./filter-tree";
+import { compileFilterTree, conditionForOperator } from "./filter-tree";
 import { CrudRequestError } from "./errors";
 import type { CrudQueryParams, EntityConfig } from "../../types";
 
@@ -58,25 +58,10 @@ export function buildListQuery({
         key = parts.pop()!;
         for (const p of parts) { if (!target[p]) target[p] = {}; target = target[p]; }
       }
-      const op = operator as string;
-      if (op === "contains") target[key] = { contains: value, mode: "insensitive" };
-      // Khoảng [từ, đến] của bộ chọn ngày. Thiếu nhánh này thì cả mảng rơi
-      // xuống `else` và đi thẳng vào Prisma dưới dạng array ⇒ nổ ở tầng driver.
-      else if (op === "between" && Array.isArray(value) && value.length === 2)
-        target[key] = { gte: value[0], lte: value[1] };
-      else if (op === "in") target[key] = { in: value };
-      else if (op === "notIn") target[key] = { notIn: value };
-      else if (op === "eq") target[key] = value;
-      else if (op === "ne") target[key] = { not: value };
-      else if (op === "gt") target[key] = { gt: value };
-      else if (op === "gte") target[key] = { gte: value };
-      else if (op === "lt") target[key] = { lt: value };
-      else if (op === "lte") target[key] = { lte: value };
-      else if (op === "startsWith") target[key] = { startsWith: value, mode: "insensitive" };
-      else if (op === "endsWith") target[key] = { endsWith: value, mode: "insensitive" };
-      else if (op === "isNull") target[key] = null;
-      else if (op === "isNotNull") target[key] = { not: null };
-      else target[key] = value;
+      // MỘT bảng toán tử cho cả hai đường (filter phẳng ở đây, `filterTree` ở
+      // dưới). Trước đây chỗ này chép lại chuỗi if riêng, và bản chép thiếu
+      // `between` — bộ lọc khoảng ngày của app khai đúng type vẫn nổ ở driver.
+      target[key] = conditionForOperator(operator as string, value);
     }
   }