corebasic 1.0.212 → 1.0.214

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

@@ -0,0 +1,99 @@
+import { entries, reduceRanges, extractBounds, getNormalizedBounds } from './index.js';
+import { formatDate, fillDates } from './date.js';
+const EXPLICIT_SUFFIX_POLICY_TYPES = new Set(["string", "date", "number"]);
+export async function suffix(doc, policies, insertMode, arg) {
+    let suffixes = [""];
+    for (const policy of policies) {
+        const value = typeof policy.value === "string" ? policy.value.trim() : undefined;
+        if ("value" in policy && !value)
+            throw new Error(`Error: Invalid suffix policy fixed 'value' specified for key in Dip`);
+        let keys = value ? [value] : entries(policy.key, doc);
+        const [policy_type, format] = (policy.type ?? "string").split(':');
+        if (!EXPLICIT_SUFFIX_POLICY_TYPES.has(policy_type))
+            throw new Error(`Error: Invalid suffix policy type specified for key ${policy.key} in Dip`);
+        if (policy_type === "string" && keys.filter(item => typeof item === "object").length)
+            throw new Error(`Error: Invalid numeric bounds on string type in suffix policy specified for key ${policy.key} in Dip`);
+        if (policy_type === "date") {
+            if (!format?.trim())
+                throw new Error(`Error: Invalid date format in suffix policy type specified for key ${policy.key} in Dip`);
+            if (format.includes('/'))
+                throw new Error(`Error: Invalid date format containing '/' in suffix policy type specified for key ${policy.key} in Dip`);
+        }
+        const ls_threshold = policy.ls_threshold ?? 5000;
+        // ====== Range ======
+        let ranges = keys.filter(item => typeof item === "object");
+        keys = keys.filter(item => typeof item !== "object");
+        if (policy_type === "date") {
+            keys = keys.map(key => formatDate(key, format));
+            if (ranges.length) {
+                ranges = extractBounds(reduceRanges(ranges));
+                const from = ranges.from ?? policy.min; // policy.min is always inclusive i.e $gte
+                const to = ranges.to ?? policy.max; // policy.max is always inclusive i.e $lte
+                const fromOp = ranges.from ? ranges.fromOp : "$gte"; // policy.min is $gte
+                const toOp = ranges.to ? ranges.toOp : "$lte"; // policy.max is $lte
+                if (from === undefined || to === undefined) {
+                    keys = []; // Fall back to Dip.operation("ls").
+                    console.warn(`Warn: Missing suffix policy min/max bound for ${policy_type} range specified for key ${policy.key} in Dip`);
+                }
+                else {
+                    ranges = fillDates({ from, to, fromOp, toOp }, format);
+                    if (!ranges.length && policy.inferRange)
+                        ranges = [...new Set([from === undefined ? undefined : formatDate(from, format), to === undefined ? undefined : formatDate(to, format)].filter(item => item))];
+                    // console.log(ranges)
+                    if (ranges.length > ls_threshold) {
+                        keys = []; // Too many suffixes to enumerate. Fall back to Dip.operation("ls").
+                        console.warn(`Warn: Suffix ls_threshold exceeded for key ${policy.key} in Dip`);
+                    }
+                    else
+                        keys.push(...ranges);
+                }
+            }
+            keys = [...new Set(keys)];
+        }
+        else if (policy_type === "number" && ranges.length) {
+            ranges = getNormalizedBounds(extractBounds(reduceRanges(ranges)), "number");
+            const from = ranges.from ?? policy.min; // policy.min is always inclusive i.e $gte
+            const to = ranges.to ?? policy.max; // policy.max is always inclusive i.e $lte
+            if (from === undefined || to === undefined) {
+                keys = []; // Fall back to Dip.operation("ls").
+                console.warn(`Warn: Missing suffix policy min/max bound for ${policy_type} range specified for key ${policy.key} in Dip`);
+            }
+            else {
+                if (to - from + 1 > ls_threshold) {
+                    keys = []; // Too many suffixes to enumerate. Fall back to Dip.operation("ls").
+                    console.warn(`Warn: Suffix ls_threshold exceeded for key ${policy.key} in Dip`);
+                }
+                else {
+                    for (let i = from; i <= to; i++)
+                        keys.push(i);
+                }
+                keys = [...new Set(keys)];
+            }
+        }
+        // =================
+        let ls = false;
+        let suffixAssociatedKeys = {};
+        if (!keys.length && insertMode)
+            throw new Error(`Error: Missing suffix policy key ${policy.key} in Dip`);
+        if (!keys.length && !insertMode) {
+            ls = true;
+            for (const suffix of suffixes) {
+                const dirs = (await Dip.operation("ls", { db: arg.db, collection: arg.collection, suffix })).filter(dir => !dir.startsWith('chunk-'));
+                suffixAssociatedKeys[suffix] = dirs;
+            }
+            console.warn(`Warn: Query omitted suffix policy key ${policy.key} in Dip. Falling back to Dip.operation(ls), incurring additional performance and network round-trip overhead.`);
+        }
+        if (!ls && keys.some(key => typeof key !== "number" && typeof key !== "string")) // Dates are already string by this point
+            throw new Error(`Error: Invalid value for suffix policy key ${policy.key} in Dip`);
+        // =================
+        const next = [];
+        for (const suffix of suffixes) {
+            const currentKeys = ls ? suffixAssociatedKeys[suffix] : keys;
+            for (const key of currentKeys) {
+                next.push(`${suffix}/${key}`);
+            }
+        }
+        suffixes = next; // The "dead branches" disappear automatically because they never contribute any children.
+    }
+    return suffixes.length === 1 && suffixes[0] === "" ? [] : suffixes;
+}

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

@@ -0,0 +1,187 @@
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { formatDate, fillDates } from "../date.js";
+describe("formatDate()", () => {
+    test("formats full date correctly", () => {
+        const date = new Date(2026, 6, 9);
+        assert.equal(formatDate(date, "YYYY-MM-DD"), "2026-07-09");
+    });
+    test("formats all tokens", () => {
+        const date = new Date(2026, 6, 9);
+        assert.equal(formatDate(date, "YYYY YY MMMM MMM MM DD D"), "2026 26 July Jul 07 09 9");
+    });
+    test("formats month names", () => {
+        const date = new Date(2026, 0, 15);
+        assert.equal(formatDate(date, "MMMM"), "January");
+        assert.equal(formatDate(date, "MMM"), "Jan");
+    });
+    test("formats december correctly", () => {
+        const date = new Date(2026, 11, 31);
+        assert.equal(formatDate(date, "MMMM MMM"), "December Dec");
+    });
+    test("pads single digit days", () => {
+        const date = new Date(2026, 6, 1);
+        assert.equal(formatDate(date, "DD"), "01");
+    });
+    test("does not pad D token", () => {
+        const date = new Date(2026, 6, 1);
+        assert.equal(formatDate(date, "D"), "1");
+    });
+    test("pads single digit months", () => {
+        const date = new Date(2026, 0, 5);
+        assert.equal(formatDate(date, "MM"), "01");
+    });
+    test("handles Date object input", () => {
+        const date = new Date(2026, 5, 20);
+        assert.equal(formatDate(date, "YYYY-MM-DD"), "2026-06-20");
+    });
+    test("handles timestamp input", () => {
+        const timestamp = new Date(2026, 5, 20).getTime();
+        assert.equal(formatDate(timestamp, "YYYY-MM-DD"), "2026-06-20");
+    });
+    test("handles ISO string input", () => {
+        assert.equal(formatDate("2026-07-09", "YYYY-MM-DD"), "2026-07-09");
+    });
+    test("handles arbitrary separators", () => {
+        const date = new Date(2026, 6, 9);
+        assert.equal(formatDate(date, "DD/MM/YYYY"), "09/07/2026");
+        assert.equal(formatDate(date, "D-MMM-YY"), "9-Jul-26");
+    });
+    test("throws for invalid date string", () => {
+        assert.throws(() => formatDate("invalid-date", "YYYY-MM-DD"));
+    });
+    test("throws for invalid timestamp", () => {
+        assert.throws(() => formatDate(NaN, "YYYY"));
+    });
+    test("handles leap day", () => {
+        const date = new Date(2024, 1, 29);
+        assert.equal(formatDate(date, "YYYY-MM-DD"), "2024-02-29");
+    });
+    test("handles year boundary", () => {
+        const date = new Date(2025, 11, 31);
+        assert.equal(formatDate(date, "YYYY-MM-DD"), "2025-12-31");
+    });
+    test("replaces longer tokens before shorter tokens", () => {
+        const date = new Date(2026, 6, 9);
+        assert.equal(formatDate(date, "MMMM MMM MM"), "July Jul 07");
+    });
+    test("keeps unknown characters untouched", () => {
+        const date = new Date(2026, 6, 9);
+        assert.equal(formatDate(date, "Today is DD-th"), "Today is 09-th");
+    });
+});
+describe("fillDates()", () => {
+    test("fills daily dates", () => {
+        assert.deepEqual(fillDates({ from: "2026-07-01", to: "2026-07-05", fromOp: "$gte", toOp: "$lte" }, "YYYY-MM-DD"), [
+            "2026-07-01",
+            "2026-07-02",
+            "2026-07-03",
+            "2026-07-04",
+            "2026-07-05",
+        ]);
+    });
+    test("fills monthly dates", () => {
+        assert.deepEqual(fillDates({ from: "2026-01-01", to: "2026-05-01", fromOp: "$gte", toOp: "$lte" }, "YYYY-MM"), [
+            "2026-01",
+            "2026-02",
+            "2026-03",
+            "2026-04",
+            "2026-05",
+        ]);
+    });
+    test("fills yearly dates", () => {
+        assert.deepEqual(fillDates({ from: "2020-01-01", to: "2024-01-01", fromOp: "$gte", toOp: "$lte" }, "YYYY"), [
+            "2020",
+            "2021",
+            "2022",
+            "2023",
+            "2024",
+        ]);
+    });
+    test("returns one value for same date", () => {
+        assert.deepEqual(fillDates({ from: "2026-07-01", to: "2026-07-01", fromOp: "$gte", toOp: "$lte" }, "YYYY-MM-DD"), [
+            "2026-07-01"
+        ]);
+    });
+    test("returns empty for reversed range", () => {
+        assert.deepEqual(fillDates({ from: "2026-07-10", to: "2026-07-01", fromOp: "$gte", toOp: "$lte" }, "YYYY-MM-DD"), []);
+    });
+    test("removes duplicates when format loses precision", () => {
+        assert.deepEqual(fillDates({ from: "2026-01-01", to: "2026-01-31", fromOp: "$gte", toOp: "$lte" }, "MMMM"), [
+            "January"
+        ]);
+    });
+    test("handles leap year traversal", () => {
+        assert.deepEqual(fillDates({ from: "2024-02-28", to: "2024-03-01", fromOp: "$gte", toOp: "$lte" }, "YYYY-MM-DD"), [
+            "2024-02-28",
+            "2024-02-29",
+            "2024-03-01",
+        ]);
+    });
+    test("handles year rollover", () => {
+        assert.deepEqual(fillDates({ from: "2025-12-30", to: "2026-01-02", fromOp: "$gte", toOp: "$lte" }, "YYYY-MM-DD"), [
+            "2025-12-30",
+            "2025-12-31",
+            "2026-01-01",
+            "2026-01-02",
+        ]);
+    });
+    test("fills across years using months", () => {
+        assert.deepEqual(fillDates({ from: "2025-11-01", to: "2026-02-01", fromOp: "$gte", toOp: "$lte" }, "YYYY-MM"), [
+            "2025-11",
+            "2025-12",
+            "2026-01",
+            "2026-02",
+        ]);
+    });
+    test("large yearly range", () => {
+        const result = fillDates({ from: "2000-01-01", to: "2020-01-01", fromOp: "$gte", toOp: "$lte" }, "YYYY");
+        assert.equal(result.length, 21);
+    });
+    test("large daily range contains no duplicates", () => {
+        const result = fillDates({ from: "2026-01-01", to: "2026-12-31", fromOp: "$gte", toOp: "$lte" }, "YYYY-MM-DD");
+        assert.equal(new Set(result).size, result.length);
+    });
+    test("excludes lower bound with $gt", () => {
+        assert.deepEqual(fillDates({
+            from: "2026-07-01",
+            to: "2026-07-03",
+            fromOp: "$gt",
+            toOp: null,
+        }, "YYYY-MM-DD"), [
+            "2026-07-02",
+            "2026-07-03",
+        ]);
+    });
+    test("excludes upper bound with $lt", () => {
+        assert.deepEqual(fillDates({
+            from: "2026-07-01",
+            to: "2026-07-03",
+            fromOp: null,
+            toOp: "$lt",
+        }, "YYYY-MM-DD"), [
+            "2026-07-01",
+            "2026-07-02",
+        ]);
+    });
+    test("excludes both bounds", () => {
+        assert.deepEqual(fillDates({
+            from: "2026-07-01",
+            to: "2026-07-05",
+            fromOp: "$gt",
+            toOp: "$lt",
+        }, "YYYY-MM-DD"), [
+            "2026-07-02",
+            "2026-07-03",
+            "2026-07-04",
+        ]);
+    });
+    test("returns empty when exclusive bounds collapse range", () => {
+        assert.deepEqual(fillDates({
+            from: "2026-07-01",
+            to: "2026-07-02",
+            fromOp: "$gt",
+            toOp: "$lt",
+        }, "YYYY-MM-DD"), []);
+    });
+});