corebasic 1.0.212 → 1.0.213

package/dist/libs/dip/suffix/tests/policy.test.js

@@ -0,0 +1,329 @@
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { matchPolicy, overlaps, contains, intersects, applySuffixPolicy } from "../policy.js";
+/* ============================================================
+ * overlaps()
+ * ============================================================ */
+describe("overlaps()", () => {
+    test("overlaps: identical ranges", () => {
+        assert.equal(overlaps({ from: 10, to: 20 }, { from: 10, to: 20 }), true);
+    });
+    test("overlaps: partial overlap", () => {
+        assert.equal(overlaps({ from: 10, to: 20 }, { from: 15, to: 25 }), true);
+    });
+    test("overlaps: no overlap", () => {
+        assert.equal(overlaps({ from: 10, to: 20 }, { from: 21, to: 30 }), false);
+    });
+    test("overlaps: open ended lower", () => {
+        assert.equal(overlaps({ to: 10 }, { from: 5 }), true);
+    });
+    test("overlaps: open ended upper", () => {
+        assert.equal(overlaps({ from: 20 }, { to: 10 }), false);
+    });
+    describe("overlaps() boundary semantics", () => {
+        test("touching: open/open does not overlap", () => {
+            assert.equal(overlaps({ to: 10, toOp: "$lt" }, { from: 10, fromOp: "$gt" }), false);
+        });
+        test("touching: closed/closed overlaps", () => {
+            assert.equal(overlaps({ to: 10, toOp: "$lte" }, { from: 10, fromOp: "$gte" }), true);
+        });
+        test("touching: closed/open does not overlap", () => {
+            assert.equal(overlaps({ to: 10, toOp: "$lte" }, { from: 10, fromOp: "$gt" }), false);
+        });
+        test("touching: open/closed does not overlap", () => {
+            assert.equal(overlaps({ to: 10, toOp: "$lt" }, { from: 10, fromOp: "$gte" }), false);
+        });
+        test("touching: reverse order closed/closed overlaps", () => {
+            assert.equal(overlaps({ from: 10, fromOp: "$gte" }, { to: 10, toOp: "$lte" }), true);
+        });
+        test("touching: reverse order open/open does not overlap", () => {
+            assert.equal(overlaps({ from: 10, fromOp: "$gt" }, { to: 10, toOp: "$lt" }), false);
+        });
+        test("identical single-point closed intervals overlap", () => {
+            assert.equal(overlaps({
+                from: 10,
+                to: 10,
+                fromOp: "$gte",
+                toOp: "$lte"
+            }, {
+                from: 10,
+                to: 10,
+                fromOp: "$gte",
+                toOp: "$lte"
+            }), true);
+        });
+        test("identical single-point open intervals do not overlap", () => {
+            assert.equal(overlaps({
+                from: 10,
+                to: 10,
+                fromOp: "$gt",
+                toOp: "$lt"
+            }, {
+                from: 10,
+                to: 10,
+                fromOp: "$gt",
+                toOp: "$lt"
+            }), false);
+        });
+        test("infinite lower bound with touching closed endpoint overlaps", () => {
+            assert.equal(overlaps({ to: 5, toOp: "$lte" }, { from: 5, fromOp: "$gte" }), true);
+        });
+        test("infinite lower bound with touching open endpoint does not overlap", () => {
+            assert.equal(overlaps({ to: 5, toOp: "$lt" }, { from: 5, fromOp: "$gt" }), false);
+        });
+    });
+});
+/* ============================================================
+ * contains()
+ * ============================================================ */
+describe("contains()", () => {
+    test("contains: inside", () => {
+        assert.equal(contains({ from: 10, to: 20 }, 15), true);
+    });
+    test("contains: below", () => {
+        assert.equal(contains({ from: 10, to: 20 }, 5), false);
+    });
+    test("contains: above", () => {
+        assert.equal(contains({ from: 10, to: 20 }, 25), false);
+    });
+    test("contains: lower bound", () => {
+        assert.equal(contains({ from: 10, to: 20 }, 10), true);
+    });
+    test("contains: upper bound", () => {
+        assert.equal(contains({ from: 10, to: 20 }, 20), true);
+    });
+    test("contains: gt excludes lower bound", () => {
+        assert.equal(contains({ from: 5, fromOp: "$gt" }, 5), false);
+    });
+    test("contains: gte includes lower bound", () => {
+        assert.equal(contains({ from: 5, fromOp: "$gte" }, 5), true);
+    });
+    test("contains: lt excludes upper bound", () => {
+        assert.equal(contains({ to: 10, toOp: "$lt" }, 10), false);
+    });
+    test("contains: lte includes upper bound", () => {
+        assert.equal(contains({ to: 10, toOp: "$lte" }, 10), true);
+    });
+    test("contains: gt/lt excludes both endpoints", () => {
+        const bounds = {
+            from: 5,
+            fromOp: "$gt",
+            to: 10,
+            toOp: "$lt"
+        };
+        assert.equal(contains(bounds, 5), false);
+        assert.equal(contains(bounds, 10), false);
+        assert.equal(contains(bounds, 7), true);
+    });
+    test("contains: gte/lte includes both endpoints", () => {
+        const bounds = {
+            from: 5,
+            fromOp: "$gte",
+            to: 10,
+            toOp: "$lte"
+        };
+        assert.equal(contains(bounds, 5), true);
+        assert.equal(contains(bounds, 10), true);
+        assert.equal(contains(bounds, 7), true);
+    });
+    test("contains: gt/lte mixed", () => {
+        const bounds = {
+            from: 5,
+            fromOp: "$gt",
+            to: 10,
+            toOp: "$lte"
+        };
+        assert.equal(contains(bounds, 5), false);
+        assert.equal(contains(bounds, 10), true);
+    });
+    test("contains: gte/lt mixed", () => {
+        const bounds = {
+            from: 5,
+            fromOp: "$gte",
+            to: 10,
+            toOp: "$lt"
+        };
+        assert.equal(contains(bounds, 5), true);
+        assert.equal(contains(bounds, 10), false);
+    });
+    test("contains: value below lower bound", () => {
+        assert.equal(contains({ from: 5, fromOp: "$gte" }, 4), false);
+    });
+    test("contains: value above upper bound", () => {
+        assert.equal(contains({ to: 10, toOp: "$lte" }, 11), false);
+    });
+    test("contains: open lower bound", () => {
+        assert.equal(contains({ to: 10, toOp: "$lte" }, -1000), true);
+    });
+    test("contains: open upper bound", () => {
+        assert.equal(contains({ from: 5, fromOp: "$gte" }, 1000), true);
+    });
+    test("contains: completely unbounded", () => {
+        assert.equal(contains({}, -100), true);
+        assert.equal(contains({}, 100), true);
+    });
+});
+/* ============================================================
+ * intersects()
+ * ============================================================ */
+describe("intersects()", () => {
+    test("intersects: value ↔ value", () => {
+        assert.equal(intersects(["A"], null, ["A"], null), true);
+    });
+    test("intersects: value ↔ value miss", () => {
+        assert.equal(intersects(["A"], null, ["B"], null), false);
+    });
+    test("intersects: value ↔ range", () => {
+        assert.equal(intersects([10], null, [], { from: 5 }), true);
+    });
+    test("intersects: value ↔ range miss", () => {
+        assert.equal(intersects([2], null, [], { from: 5 }), false);
+    });
+    test("intersects: range ↔ value", () => {
+        assert.equal(intersects([], { from: 5 }, [10], null), true);
+    });
+    test("intersects: range ↔ value miss", () => {
+        assert.equal(intersects([], { from: 5 }, [2], null), false);
+    });
+    test("intersects: range ↔ range", () => {
+        assert.equal(intersects([], { from: 10 }, [], { from: 20 }), true);
+    });
+    test("intersects: range ↔ range miss", () => {
+        assert.equal(intersects([], { to: 5 }, [], { from: 10 }), false);
+    });
+});
+/* ============================================================
+ * matchPolicy()
+ * ============================================================ */
+describe("matchPolicy()", () => {
+    test("empty when", () => {
+        assert.equal(matchPolicy({}, {}), true);
+    });
+    test("simple equality", () => {
+        assert.equal(matchPolicy({ status: "Active" }, { status: "Active" }), true);
+    });
+    test("simple equality fail", () => {
+        assert.equal(matchPolicy({ status: "Pending" }, { status: "Active" }), false);
+    });
+    test("$in subset", () => {
+        assert.equal(matchPolicy({ status: { $in: ["Active", "Pending"] } }, { status: { $in: ["Active"] } }), true);
+    });
+    test("$in miss", () => {
+        assert.equal(matchPolicy({ status: { $in: ["Pending"] } }, { status: { $in: ["Active"] } }), false);
+    });
+    test("value ↔ range", () => {
+        assert.equal(matchPolicy({ age: 10 }, { age: { $gt: 5 } }), true);
+    });
+    test("value ↔ range miss", () => {
+        assert.equal(matchPolicy({ age: 2 }, { age: { $gt: 5 } }), false);
+    });
+    test("range ↔ value", () => {
+        assert.equal(matchPolicy({ age: { $gt: 5 } }, { age: 10 }), true);
+    });
+    test("range ↔ value miss", () => {
+        assert.equal(matchPolicy({ age: { $lt: 5 } }, { age: 10 }), false);
+    });
+    test("range ↔ range overlap", () => {
+        assert.equal(matchPolicy({ age: { $gt: 15 } }, { age: { $gt: 10 } }), true);
+    });
+    test("range ↔ range miss", () => {
+        assert.equal(matchPolicy({ age: { $lt: 5 } }, { age: { $gt: 10 } }), false);
+    });
+    test("multiple keys", () => {
+        assert.equal(matchPolicy({
+            status: "Active",
+            age: 20
+        }, {
+            status: "Active",
+            age: { $gt: 10 }
+        }), true);
+    });
+    test("multiple keys fail", () => {
+        assert.equal(matchPolicy({
+            status: "Pending",
+            age: 20
+        }, {
+            status: "Active",
+            age: { $gt: 10 }
+        }), false);
+    });
+    test("$and flatten", () => {
+        assert.equal(matchPolicy({
+            status: "Active",
+            region: "IN"
+        }, {
+            $and: [
+                { status: "Active" },
+                { region: "IN" }
+            ]
+        }), true);
+    });
+    test("$and flatten fail", () => {
+        assert.equal(matchPolicy({
+            status: "Active",
+            region: "US"
+        }, {
+            $and: [
+                { status: "Active" },
+                { region: "IN" }
+            ]
+        }), false);
+    });
+    test("$or merge semantics", () => {
+        assert.equal(matchPolicy({
+            status: {
+                $in: ["Active", "Pending"]
+            }
+        }, {
+            $or: [
+                { status: "Active" },
+                { status: "Pending" }
+            ]
+        }), true);
+    });
+    test("$ne throws", () => {
+        assert.throws(() => {
+            matchPolicy({ status: "Deleted" }, {
+                status: {
+                    $ne: "Deleted"
+                }
+            });
+        });
+    });
+    test("$nin throws", () => {
+        assert.throws(() => {
+            matchPolicy({ status: "Deleted" }, {
+                status: {
+                    $nin: ["Deleted"]
+                }
+            });
+        });
+    });
+    test("$not throws", () => {
+        assert.throws(() => {
+            matchPolicy({ age: 10 }, {
+                age: {
+                    $not: {
+                        $gt: 5
+                    }
+                }
+            });
+        });
+    });
+    test("conservative planner: identical lt", () => {
+        assert.equal(matchPolicy({ age: { $lt: 10 } }, { age: { $lt: 10 } }), true);
+    });
+    test("conservative planner: identical gt", () => {
+        assert.equal(matchPolicy({ age: { $gt: 10 } }, { age: { $gt: 10 } }), true);
+    });
+    test("mixed value + range", () => {
+        assert.equal(matchPolicy({
+            age: {
+                $in: [10],
+                $gt: 20
+            }
+        }, {
+            age: 10
+        }), true);
+    });
+});

package/dist/libs/dip/suffix/tests/suffix.test.js

@@ -0,0 +1,316 @@
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { suffix } from "../suffix.js";
+describe("suffix()", () => {
+    test("returns empty suffixes when no policies exist", async () => {
+        const result = await suffix({}, [], true, {});
+        assert.deepEqual(result, []);
+    });
+    test("generates string suffix from fixed value", async () => {
+        const result = await suffix({}, [
+            {
+                type: "string",
+                value: "hello"
+            }
+        ], true, {});
+        assert.deepEqual(result, [
+            "/hello"
+        ]);
+    });
+    test("trims fixed string values", async () => {
+        const result = await suffix({}, [
+            {
+                type: "string",
+                value: "  hello  "
+            }
+        ], true, {});
+        assert.deepEqual(result, [
+            "/hello"
+        ]);
+    });
+    test("rejects empty fixed value", async () => {
+        await assert.rejects(() => suffix({}, [
+            {
+                type: "string",
+                value: " "
+            }
+        ], true, {}));
+    });
+    test("uses document key for string policy", async () => {
+        const result = await suffix({
+            name: "alice"
+        }, [
+            {
+                type: "string",
+                key: "name"
+            }
+        ], true, {});
+        assert.deepEqual(result, [
+            "/alice"
+        ]);
+    });
+    test("supports multiple policies and cartesian expansion", async () => {
+        const result = await suffix({
+            category: "books",
+            year: 2026
+        }, [
+            {
+                type: "string",
+                key: "category"
+            },
+            {
+                type: "number",
+                key: "year"
+            }
+        ], true, {});
+        assert.deepEqual(result, [
+            "/books/2026"
+        ]);
+    });
+    test("supports multiple values from document key", async () => {
+        const result = await suffix({
+            tags: [
+                "a",
+                "b",
+                "c"
+            ]
+        }, [
+            {
+                type: "string",
+                key: "tags"
+            }
+        ], true, {});
+        assert.deepEqual(result.sort(), [
+            "/a",
+            "/b",
+            "/c"
+        ]);
+    });
+    test("number policy accepts numeric values", async () => {
+        const result = await suffix({
+            age: 42
+        }, [
+            {
+                type: "number",
+                key: "age"
+            }
+        ], true, {});
+        assert.deepEqual(result, [
+            "/42"
+        ]);
+    });
+    test("rejects invalid suffix policy type", async () => {
+        await assert.rejects(() => suffix({}, [
+            {
+                type: "boolean",
+                value: true
+            }
+        ], true, {}));
+    });
+    test("defaults type to string", async () => {
+        const result = await suffix({
+            id: "abc"
+        }, [
+            {
+                key: "id"
+            }
+        ], true, {});
+        assert.deepEqual(result, [
+            "/abc"
+        ]);
+    });
+    test("rejects invalid date type without format", async () => {
+        await assert.rejects(() => suffix({
+            created: "2026-07-09"
+        }, [
+            {
+                type: "date",
+                key: "created"
+            }
+        ], true, {}));
+    });
+    test("rejects date format containing slash", async () => {
+        await assert.rejects(() => suffix({
+            created: "2026-07-09"
+        }, [
+            {
+                type: "date:YYYY/MM/DD",
+                key: "created"
+            }
+        ], true, {}));
+    });
+    test("formats date suffix", async () => {
+        const result = await suffix({
+            created: "2026-07-09"
+        }, [
+            {
+                type: "date:YYYY-MM-DD",
+                key: "created"
+            }
+        ], true, {});
+        assert.deepEqual(result, [
+            "/2026-07-09"
+        ]);
+    });
+    test("deduplicates suffixes", async () => {
+        const result = await suffix({
+            tags: [
+                "a",
+                "a",
+                "b"
+            ]
+        }, [
+            {
+                type: "string",
+                key: "tags"
+            }
+        ], true, {});
+        assert.deepEqual(result.sort(), [
+            "/a",
+            "/b"
+        ]);
+    });
+    test("rejects missing insert key", async () => {
+        await assert.rejects(() => suffix({}, [
+            {
+                type: "string",
+                key: "missing"
+            }
+        ], true, {}));
+    });
+    test("number range expands inclusive bounds", async () => {
+        const result = await suffix({
+            score: {
+                $gte: 1,
+                $lte: 3
+            }
+        }, [
+            {
+                type: "number",
+                key: "score"
+            }
+        ], true, {});
+        assert.deepEqual(result.sort(), [
+            "/1",
+            "/2",
+            "/3"
+        ]);
+    });
+    test("number range uses explicit min/max", async () => {
+        const result = await suffix({
+            score: {
+                $gte: 1,
+                $lte: 2
+            }
+        }, [
+            {
+                type: "number",
+                key: "score",
+                min: 5,
+                max: 7
+            }
+        ], true, {});
+        assert.deepEqual(result.sort(), ["/1", "/2"]);
+    });
+    test("number range uses policy max fallback", async () => {
+        const result = await suffix({
+            score: {
+                $gte: 5
+            }
+        }, [
+            {
+                type: "number",
+                key: "score",
+                max: 7
+            }
+        ], true, {});
+        assert.deepEqual(result.sort(), ["/5", "/6", "/7"]);
+    });
+    test("number range uses policy min fallback", async () => {
+        const result = await suffix({
+            score: {
+                $lte: 7
+            }
+        }, [
+            {
+                type: "number",
+                key: "score",
+                min: 5
+            }
+        ], true, {});
+        assert.deepEqual(result.sort(), ["/5", "/6", "/7"]);
+    });
+    test("date range expands dates", async () => {
+        const result = await suffix({
+            created: {
+                $gte: "2026-01-01",
+                $lte: "2026-01-03"
+            }
+        }, [
+            {
+                type: "date:YYYY-MM-DD",
+                key: "created"
+            }
+        ], true, {});
+        assert.deepEqual(result.sort(), [
+            "/2026-01-01",
+            "/2026-01-02",
+            "/2026-01-03"
+        ]);
+    });
+    test("throws when ls threshold exceeded for number range", async () => {
+        await assert.rejects(() => suffix({
+            value: {
+                $gte: 1,
+                $lte: 100
+            }
+        }, [
+            {
+                type: "number",
+                key: "value",
+                ls_threshold: 5
+            }
+        ], true, {}));
+    });
+    test("throws when ls threshold exceeded for date range", async () => {
+        await assert.rejects(() => suffix({
+            created: {
+                $gte: "2026-01-01",
+                $lte: "2026-01-10"
+            }
+        }, [
+            {
+                type: "date:YYYY-MM-DD",
+                key: "created",
+                ls_threshold: 2
+            }
+        ], true, {}));
+    });
+    test("creates cartesian product for multiple suffix values", async () => {
+        const result = await suffix({
+            a: [
+                "x",
+                "y"
+            ],
+            b: [
+                1,
+                2
+            ]
+        }, [
+            {
+                type: "string",
+                key: "a"
+            },
+            {
+                type: "number",
+                key: "b"
+            }
+        ], true, {});
+        assert.deepEqual(result.sort(), [
+            "/x/1",
+            "/x/2",
+            "/y/1",
+            "/y/2"
+        ]);
+    });
+});