corebasic 1.0.230 → 1.0.232

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

@@ -8,11 +8,16 @@ export async function suffix(doc, policies, insertMode, arg) {
         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(':');
+        let candidates = value ? [value] : entries(policy.key ?? '', doc);
+        const [policy_type, format_type] = (policy.type ?? "string").split(':');
+        const format = format_type ?? "";
         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)
+        // ====== Range ======
+        let ranges = candidates.filter(item => typeof item === "object");
+        let keys = candidates.filter(item => typeof item !== "object");
+        // ====== Range ======
+        if (policy_type === "string" && ranges.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())
@@ -22,14 +27,12 @@ export async function suffix(doc, policies, insertMode, arg) {
         }
         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) {
                 const bounds = extractBounds(reduceRanges(ranges));
-                const from = bounds.from ?? policy.min; // policy.min is always inclusive i.e $gte
-                const to = bounds.to ?? policy.max; // policy.max is always inclusive i.e $lte
+                const from = (bounds.from ?? policy.min); // policy.min is always inclusive i.e $gte
+                const to = (bounds.to ?? policy.max); // policy.max is always inclusive i.e $lte
                 const fromOp = bounds.from ? bounds.fromOp : "$gte"; // policy.min is $gte
                 const toOp = bounds.to ? bounds.toOp : "$lte"; // policy.max is $lte
                 if (from === undefined || to === undefined) {
@@ -38,8 +41,8 @@ export async function suffix(doc, policies, insertMode, arg) {
                 }
                 else {
                     let 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))];
+                    // 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").
@@ -53,8 +56,8 @@ export async function suffix(doc, policies, insertMode, arg) {
         }
         else if (policy_type === "number" && ranges.length) {
             const bounds = getNormalizedBounds(extractBounds(reduceRanges(ranges)), "number");
-            const from = bounds.from ?? policy.min; // policy.min is always inclusive i.e $gte
-            const to = bounds.to ?? policy.max; // policy.max is always inclusive i.e $lte
+            const from = (bounds.from ?? policy.min); // policy.min is always inclusive i.e $gte
+            const to = (bounds.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`);
@@ -79,8 +82,9 @@ export async function suffix(doc, policies, insertMode, arg) {
         if (!keys.length && !insertMode) {
             ls = true;
             for (const suffix of suffixes) {
-                for (const collection of arg.collection) {
-                    const dirs = (await Dip.operation("ls", { db: arg.db, collection: collection, suffix })).filter(dir => !dir.startsWith('chunk-'));
+                const collections = arg?.collection ?? [];
+                for (const collection of collections) {
+                    const dirs = (await Dip.operation("ls", { db: arg?.db, collection: collection, suffix })).filter((dir) => !dir.startsWith('chunk-'));
                     suffixAssociatedKeys[suffix] = suffixAssociatedKeys[suffix] ?? [];
                     suffixAssociatedKeys[suffix].push(...dirs);
                 }

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

@@ -142,46 +142,33 @@ describe("fillDates()", () => {
         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 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"), [
+        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"), []);
+        assert.deepEqual(fillDates({ from: "2026-07-01", to: "2026-07-02", fromOp: "$gt", toOp: "$lt" }, "YYYY-MM-DD"), []);
     });
 });

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

@@ -1,75 +1,56 @@
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
 import { matchPolicy, overlaps, contains, intersects, applySuffixPolicy } from "../policy.js";
+const defaultBounds = { values: [], from: -Infinity, to: Infinity, fromOp: "$gte", toOp: "$lte" };
 /* ============================================================
  * overlaps()
  * ============================================================ */
 describe("overlaps()", () => {
     test("overlaps: identical ranges", () => {
-        assert.equal(overlaps({ from: 10, to: 20 }, { from: 10, to: 20 }), true);
+        assert.equal(overlaps({ ...defaultBounds, from: 10, to: 20 }, { ...defaultBounds, from: 10, to: 20 }), true);
     });
     test("overlaps: partial overlap", () => {
-        assert.equal(overlaps({ from: 10, to: 20 }, { from: 15, to: 25 }), true);
+        assert.equal(overlaps({ ...defaultBounds, from: 10, to: 20 }, { ...defaultBounds, from: 15, to: 25 }), true);
     });
     test("overlaps: no overlap", () => {
-        assert.equal(overlaps({ from: 10, to: 20 }, { from: 21, to: 30 }), false);
+        assert.equal(overlaps({ ...defaultBounds, from: 10, to: 20 }, { ...defaultBounds, from: 21, to: 30 }), false);
     });
     test("overlaps: open ended lower", () => {
-        assert.equal(overlaps({ to: 10 }, { from: 5 }), true);
+        assert.equal(overlaps({ ...defaultBounds, to: 10 }, { ...defaultBounds, from: 5 }), true);
     });
     test("overlaps: open ended upper", () => {
-        assert.equal(overlaps({ from: 20 }, { to: 10 }), false);
+        assert.equal(overlaps({ ...defaultBounds, from: 20 }, { ...defaultBounds, 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);
+            assert.equal(overlaps({ ...defaultBounds, to: 10, toOp: "$lt" }, { ...defaultBounds, from: 10, fromOp: "$gt" }), false);
         });
         test("touching: closed/closed overlaps", () => {
-            assert.equal(overlaps({ to: 10, toOp: "$lte" }, { from: 10, fromOp: "$gte" }), true);
+            assert.equal(overlaps({ ...defaultBounds, to: 10, toOp: "$lte" }, { ...defaultBounds, from: 10, fromOp: "$gte" }), true);
         });
         test("touching: closed/open does not overlap", () => {
-            assert.equal(overlaps({ to: 10, toOp: "$lte" }, { from: 10, fromOp: "$gt" }), false);
+            assert.equal(overlaps({ ...defaultBounds, to: 10, toOp: "$lte" }, { ...defaultBounds, from: 10, fromOp: "$gt" }), false);
         });
         test("touching: open/closed does not overlap", () => {
-            assert.equal(overlaps({ to: 10, toOp: "$lt" }, { from: 10, fromOp: "$gte" }), false);
+            assert.equal(overlaps({ ...defaultBounds, to: 10, toOp: "$lt" }, { ...defaultBounds, from: 10, fromOp: "$gte" }), false);
         });
         test("touching: reverse order closed/closed overlaps", () => {
-            assert.equal(overlaps({ from: 10, fromOp: "$gte" }, { to: 10, toOp: "$lte" }), true);
+            assert.equal(overlaps({ ...defaultBounds, from: 10, fromOp: "$gte" }, { ...defaultBounds, 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);
+            assert.equal(overlaps({ ...defaultBounds, from: 10, fromOp: "$gt" }, { ...defaultBounds, 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);
+            assert.equal(overlaps({ ...defaultBounds, from: 10, to: 10, fromOp: "$gte", toOp: "$lte" }, { ...defaultBounds, 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);
+            assert.equal(overlaps({ ...defaultBounds, from: 10, to: 10, fromOp: "$gt", toOp: "$lt" }, { ...defaultBounds, 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);
+            assert.equal(overlaps({ ...defaultBounds, to: 5, toOp: "$lte" }, { ...defaultBounds, 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);
+            assert.equal(overlaps({ ...defaultBounds, to: 5, toOp: "$lt" }, { ...defaultBounds, from: 5, fromOp: "$gt" }), false);
         });
     });
 });
@@ -78,89 +59,69 @@ describe("overlaps()", () => {
  * ============================================================ */
 describe("contains()", () => {
     test("contains: inside", () => {
-        assert.equal(contains({ from: 10, to: 20 }, 15), true);
+        assert.equal(contains({ ...defaultBounds, from: 10, to: 20 }, 15), true);
     });
     test("contains: below", () => {
-        assert.equal(contains({ from: 10, to: 20 }, 5), false);
+        assert.equal(contains({ ...defaultBounds, from: 10, to: 20 }, 5), false);
     });
     test("contains: above", () => {
-        assert.equal(contains({ from: 10, to: 20 }, 25), false);
+        assert.equal(contains({ ...defaultBounds, from: 10, to: 20 }, 25), false);
     });
     test("contains: lower bound", () => {
-        assert.equal(contains({ from: 10, to: 20 }, 10), true);
+        assert.equal(contains({ ...defaultBounds, from: 10, to: 20 }, 10), true);
     });
     test("contains: upper bound", () => {
-        assert.equal(contains({ from: 10, to: 20 }, 20), true);
+        assert.equal(contains({ ...defaultBounds, from: 10, to: 20 }, 20), true);
     });
     test("contains: gt excludes lower bound", () => {
-        assert.equal(contains({ from: 5, fromOp: "$gt" }, 5), false);
+        assert.equal(contains({ ...defaultBounds, from: 5, fromOp: "$gt" }, 5), false);
     });
     test("contains: gte includes lower bound", () => {
-        assert.equal(contains({ from: 5, fromOp: "$gte" }, 5), true);
+        assert.equal(contains({ ...defaultBounds, from: 5, fromOp: "$gte" }, 5), true);
     });
     test("contains: lt excludes upper bound", () => {
-        assert.equal(contains({ to: 10, toOp: "$lt" }, 10), false);
+        assert.equal(contains({ ...defaultBounds, to: 10, toOp: "$lt" }, 10), false);
     });
     test("contains: lte includes upper bound", () => {
-        assert.equal(contains({ to: 10, toOp: "$lte" }, 10), true);
+        assert.equal(contains({ ...defaultBounds, to: 10, toOp: "$lte" }, 10), true);
     });
     test("contains: gt/lt excludes both endpoints", () => {
-        const bounds = {
-            from: 5,
-            fromOp: "$gt",
-            to: 10,
-            toOp: "$lt"
-        };
+        const bounds = { ...defaultBounds, 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"
-        };
+        const bounds = { ...defaultBounds, 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"
-        };
+        const bounds = { ...defaultBounds, 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"
-        };
+        const bounds = { ...defaultBounds, 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);
+        assert.equal(contains({ ...defaultBounds, from: 5, fromOp: "$gte" }, 4), false);
     });
     test("contains: value above upper bound", () => {
-        assert.equal(contains({ to: 10, toOp: "$lte" }, 11), false);
+        assert.equal(contains({ ...defaultBounds, to: 10, toOp: "$lte" }, 11), false);
     });
     test("contains: open lower bound", () => {
-        assert.equal(contains({ to: 10, toOp: "$lte" }, -1000), true);
+        assert.equal(contains({ ...defaultBounds, to: 10, toOp: "$lte" }, -1000), true);
     });
     test("contains: open upper bound", () => {
-        assert.equal(contains({ from: 5, fromOp: "$gte" }, 1000), true);
+        assert.equal(contains({ ...defaultBounds, from: 5, fromOp: "$gte" }, 1000), true);
     });
     test("contains: completely unbounded", () => {
-        assert.equal(contains({}, -100), true);
-        assert.equal(contains({}, 100), true);
+        assert.equal(contains({ ...defaultBounds, }, -100), true);
+        assert.equal(contains({ ...defaultBounds, }, 100), true);
     });
 });
 /* ============================================================
@@ -174,22 +135,22 @@ describe("intersects()", () => {
         assert.equal(intersects(["A"], null, ["B"], null), false);
     });
     test("intersects: value ↔ range", () => {
-        assert.equal(intersects([10], null, [], { from: 5 }), true);
+        assert.equal(intersects([10], null, [], { ...defaultBounds, from: 5 }), true);
     });
     test("intersects: value ↔ range miss", () => {
-        assert.equal(intersects([2], null, [], { from: 5 }), false);
+        assert.equal(intersects([2], null, [], { ...defaultBounds, from: 5 }), false);
     });
     test("intersects: range ↔ value", () => {
-        assert.equal(intersects([], { from: 5 }, [10], null), true);
+        assert.equal(intersects([], { ...defaultBounds, from: 5 }, [10], null), true);
     });
     test("intersects: range ↔ value miss", () => {
-        assert.equal(intersects([], { from: 5 }, [2], null), false);
+        assert.equal(intersects([], { ...defaultBounds, from: 5 }, [2], null), false);
     });
     test("intersects: range ↔ range", () => {
-        assert.equal(intersects([], { from: 10 }, [], { from: 20 }), true);
+        assert.equal(intersects([], { ...defaultBounds, from: 10 }, [], { ...defaultBounds, from: 20 }), true);
     });
     test("intersects: range ↔ range miss", () => {
-        assert.equal(intersects([], { to: 5 }, [], { from: 10 }), false);
+        assert.equal(intersects([], { ...defaultBounds, to: 5 }, [], { ...defaultBounds, from: 10 }), false);
     });
 });
 /* ============================================================

package/dist/libs/dip.js

@@ -15,6 +15,7 @@ export const companyMeta = Elabase.companyMeta;
 export const outletMeta = Elabase.outletMeta;
 export const customMeta = Elabase.customMeta;
 export const schema = Elabase.schema;
+export const DipMeta = Elabase.DipMeta;
 export const isDipMeta = Elabase.isDipMeta;
 export const excludeCollectionConfig = Elabase.excludeCollectionConfig;
 export const includeCollectionConfig = Elabase.includeCollectionConfig;
@@ -28,34 +29,36 @@ export async function insertSync(meta, feature, date, uid, ref, type) {
     await Elabase.insert(meta, collection, data);
 }
 export const IdempotentDip = () => {
-    return {
+    const state = {
         txn: '',
         meta: undefined,
-        new: (async function (meta, txn, blank) {
-            this.txn = txn;
-            this.meta = meta;
-            return blank ? this : ((await Elabase.query(this.meta, "txns", { _id: this.txn })).length ? false : this);
-        }),
-        insert: (async function (collection, query, data) {
-            await Elabase.update(this.meta, collection, query, { $setOnInsert: data }, { upsert: true });
-        }),
-        update: (async function (collection, query, data, rollback) {
-            let token = { [this.txn]: true };
-            let idempotent = { [this.txn]: { $exists: rollback ?? false } };
-            let result = await Elabase.update(this.meta, collection, { ...query, ...idempotent }, { ...data, $setOnInsert: undefined, $set: { ...(data.$set ?? {}), ...token } });
-            return result.count ? true : (await Elabase.query(this.meta, collection, { ...query, ...idempotent })).length;
-        }),
-        upsert: (async function (collection, query, data, rollback) {
-            await this.insert(collection, query, data.$setOnInsert);
-            return await this.update(collection, query, data, rollback);
-        }),
-        cleanup: (async function (collection, query) {
-            await Elabase.update(this.meta, collection, query, { $unset: { [this.txn]: true } });
-        }),
-        finish: (async function () {
-            return await Elabase.update(this.meta, "txns", { _id: this.txn }, {}, { upsert: true });
-        })
     };
+    const idip = {};
+    idip.new = async function (meta, txn, blank) {
+        state.txn = txn;
+        state.meta = meta;
+        return blank ? idip : ((await Elabase.query(state.meta, "txns", { _id: state.txn })).length ? false : idip);
+    };
+    idip.insert = async function (collection, query, data) {
+        await Elabase.update(state.meta, collection, query, { $setOnInsert: data }, { upsert: true });
+    };
+    idip.update = async function (collection, query, data, rollback) {
+        let token = { [state.txn]: true };
+        let idempotent = { [state.txn]: { $exists: rollback ?? false } };
+        let result = await Elabase.update(state.meta, collection, { ...query, ...idempotent }, { ...data, $setOnInsert: undefined, $set: { ...(data.$set ?? {}), ...token } });
+        return result.count ? true : (await Elabase.query(state.meta, collection, { ...query, ...idempotent })).length;
+    };
+    idip.upsert = async function (collection, query, data, rollback) {
+        await idip.insert(collection, query, data.$setOnInsert);
+        return await idip.update(collection, query, data, rollback);
+    };
+    idip.cleanup = async function (collection, query) {
+        await Elabase.update(state.meta, collection, query, { $unset: { [state.txn]: true } });
+    };
+    idip.finish = async function () {
+        return await Elabase.update(state.meta, "txns", { _id: state.txn }, {}, { upsert: true });
+    };
+    return idip;
 };
 export const idip = async (message, callback, cleanup) => {
     if (!callback)
@@ -93,7 +96,7 @@ export const insertKeys = (message, meta) => {
         ...(meta?.outlet ? { "outlet": meta.outlet } : {}),
     };
 };
-export const updateKeys = message => {
+export const updateKeys = (message) => {
     return {
         "updated": message.date,
         "updatedBy": message.meta.staff,

package/dist/libs/dipper.js

@@ -1,6 +1,5 @@
 // @ts-ignore
 import axios from 'axios';
-// import {curly} from 'node-libcurl'
 function hashStr(str) {
     let hash = 0;
     for (let i = 0; i < str.length; i++) {

package/dist/libs/elabase.js

@@ -43,7 +43,7 @@ function deepFreeze(obj) {
     }
     return obj;
 }
-class DipMeta {
+export class DipMeta {
     constructor(obj) {
         Object.assign(this, deepFreeze(obj));
         Object.freeze(this);