corebasic 1.0.206 → 1.0.208

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

@@ -0,0 +1,622 @@
+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"
+            ]
+        );
+
+    });
+
+
+});

package/libs/dip.js

@@ -67,9 +67,9 @@ export const IdempotentDip = () => {
 
 export const idip = async (message, callback, cleanup) => {
     if (!callback)
-        throw {message: "Dip.idip() callback argument undefined"}
+        throw new Error("Dip.idip() callback argument undefined")
     if (!cleanup)
-        throw {message: "Dip.idip() cleanup argument undefined"}
+        throw new Error("Dip.idip() cleanup argument undefined")
     async function doCleanup(IDip) {
         if (typeof cleanup === 'object') {
             for (let collection in cleanup)
@@ -91,7 +91,7 @@ export const idip = async (message, callback, cleanup) => {
 
 
 export const insertKeys = (message, meta) => {
-    if (!isDipMeta(meta)) throw {message: 'Error: Provided meta is not an instance of DipMeta in Dip.insertKeys()'}
+    if (!isDipMeta(meta)) throw new Error('Error: Provided meta is not an instance of DipMeta in Dip.insertKeys()')
     return {
         "created": message.date, "updated": message.date,
         "createdBy": message.meta.staff,