corebasic 1.0.229 → 1.0.231

package/libs/dip/suffix/tests/policy.test.ts

@@ -2,6 +2,7 @@ import { describe, test } from "node:test";
 import assert from "node:assert/strict";
 import {matchPolicy, overlaps, contains, intersects, applySuffixPolicy} from "../policy.ts";
 
+const defaultBounds = {values: [], from: -Infinity, to: Infinity, fromOp: "$gte", toOp: "$lte"}
 
 /* ============================================================
  * overlaps()
@@ -10,35 +11,35 @@ describe("overlaps()", () => {
 
     test("overlaps: identical ranges", () => {
         assert.equal(
-            overlaps({ from: 10, to: 20 }, { from: 10, to: 20 }),
+            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 }),
+            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 }),
+            overlaps({ ...defaultBounds, from: 10, to: 20 }, { ...defaultBounds, from: 21, to: 30 }),
             false
         );
     });
 
     test("overlaps: open ended lower", () => {
         assert.equal(
-            overlaps({ to: 10 }, { from: 5 }),
+            overlaps({ ...defaultBounds, to: 10 }, { ...defaultBounds, from: 5 }),
             true
         );
     });
 
     test("overlaps: open ended upper", () => {
         assert.equal(
-            overlaps({ from: 20 }, { to: 10 }),
+            overlaps({ ...defaultBounds, from: 20 }, { ...defaultBounds, to: 10 }),
             false
         );
     });
@@ -48,39 +49,28 @@ describe("overlaps()", () => {
 
         test("touching: open/open does not overlap", () => {
             assert.equal(
-                overlaps(
-                    { to: 10, toOp: "$lt" },
-                    { from: 10, fromOp: "$gt" }
-                ),
+                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" }
-                ),
+                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" }
-                ),
+                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" }
+                overlaps({ ...defaultBounds, to: 10, toOp: "$lt" }, { ...defaultBounds, from: 10, fromOp: "$gte" }
                 ),
                 false
             );
@@ -88,80 +78,42 @@ describe("overlaps()", () => {
 
         test("touching: reverse order closed/closed overlaps", () => {
             assert.equal(
-                overlaps(
-                    { from: 10, fromOp: "$gte" },
-                    { to: 10, toOp: "$lte" }
-                ),
+                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" }
-                ),
+                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"
-                    }
-                ),
+                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"
-                    }
-                ),
+                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" }
-                ),
+                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" }
-                ),
+                overlaps({ ...defaultBounds, to: 5, toOp: "$lt" }, { ...defaultBounds, from: 5, fromOp: "$gt" }),
                 false
             );
         });
@@ -178,35 +130,35 @@ describe("contains()", () => {
 
     test("contains: inside", () => {
         assert.equal(
-            contains({ from: 10, to: 20 }, 15),
+            contains({ ...defaultBounds, from: 10, to: 20 }, 15),
             true
         );
     });
 
     test("contains: below", () => {
         assert.equal(
-            contains({ from: 10, to: 20 }, 5),
+            contains({ ...defaultBounds, from: 10, to: 20 }, 5),
             false
         );
     });
 
     test("contains: above", () => {
         assert.equal(
-            contains({ from: 10, to: 20 }, 25),
+            contains({ ...defaultBounds, from: 10, to: 20 }, 25),
             false
         );
     });
 
     test("contains: lower bound", () => {
         assert.equal(
-            contains({ from: 10, to: 20 }, 10),
+            contains({ ...defaultBounds, from: 10, to: 20 }, 10),
             true
         );
     });
 
     test("contains: upper bound", () => {
         assert.equal(
-            contains({ from: 10, to: 20 }, 20),
+            contains({ ...defaultBounds, from: 10, to: 20 }, 20),
             true
         );
     });
@@ -214,39 +166,34 @@ describe("contains()", () => {
 
     test("contains: gt excludes lower bound", () => {
         assert.equal(
-            contains({ from: 5, fromOp: "$gt" }, 5),
+            contains({ ...defaultBounds, from: 5, fromOp: "$gt" }, 5),
                      false
         );
     });
 
     test("contains: gte includes lower bound", () => {
         assert.equal(
-            contains({ from: 5, fromOp: "$gte" }, 5),
+            contains({ ...defaultBounds, from: 5, fromOp: "$gte" }, 5),
                      true
         );
     });
 
     test("contains: lt excludes upper bound", () => {
         assert.equal(
-            contains({ to: 10, toOp: "$lt" }, 10),
+            contains({ ...defaultBounds, to: 10, toOp: "$lt" }, 10),
                      false
         );
     });
 
     test("contains: lte includes upper bound", () => {
         assert.equal(
-            contains({ to: 10, toOp: "$lte" }, 10),
+            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);
@@ -254,12 +201,7 @@ describe("contains()", () => {
     });
 
     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);
@@ -267,24 +209,14 @@ describe("contains()", () => {
     });
 
     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);
@@ -292,39 +224,39 @@ describe("contains()", () => {
 
     test("contains: value below lower bound", () => {
         assert.equal(
-            contains({ from: 5, fromOp: "$gte" }, 4),
+            contains({ ...defaultBounds, from: 5, fromOp: "$gte" }, 4),
                      false
         );
     });
 
     test("contains: value above upper bound", () => {
         assert.equal(
-            contains({ to: 10, toOp: "$lte" }, 11),
+            contains({ ...defaultBounds, to: 10, toOp: "$lte" }, 11),
                      false
         );
     });
 
     test("contains: open lower bound", () => {
         assert.equal(
-            contains({ to: 10, toOp: "$lte" }, -1000),
+            contains({ ...defaultBounds, to: 10, toOp: "$lte" }, -1000),
                      true
         );
     });
 
     test("contains: open upper bound", () => {
         assert.equal(
-            contains({ from: 5, fromOp: "$gte" }, 1000),
+            contains({ ...defaultBounds, from: 5, fromOp: "$gte" }, 1000),
                      true
         );
     });
 
     test("contains: completely unbounded", () => {
         assert.equal(
-            contains({}, -100),
+            contains({ ...defaultBounds, }, -100),
                      true
         );
         assert.equal(
-            contains({}, 100),
+            contains({ ...defaultBounds, }, 100),
                      true
         );
     });
@@ -353,42 +285,42 @@ describe("intersects()", () => {
 
     test("intersects: value ↔ range", () => {
         assert.equal(
-            intersects([10], null, [], { from: 5 }),
+            intersects([10], null, [], { ...defaultBounds, from: 5 }),
             true
         );
     });
 
     test("intersects: value ↔ range miss", () => {
         assert.equal(
-            intersects([2], null, [], { from: 5 }),
+            intersects([2], null, [], { ...defaultBounds, from: 5 }),
             false
         );
     });
 
     test("intersects: range ↔ value", () => {
         assert.equal(
-            intersects([], { from: 5 }, [10], null),
+            intersects([], { ...defaultBounds, from: 5 }, [10], null),
             true
         );
     });
 
     test("intersects: range ↔ value miss", () => {
         assert.equal(
-            intersects([], { from: 5 }, [2], null),
+            intersects([], { ...defaultBounds, from: 5 }, [2], null),
             false
         );
     });
 
     test("intersects: range ↔ range", () => {
         assert.equal(
-            intersects([], { from: 10 }, [], { from: 20 }),
+            intersects([], { ...defaultBounds, from: 10 }, [], { ...defaultBounds, from: 20 }),
             true
         );
     });
 
     test("intersects: range ↔ range miss", () => {
         assert.equal(
-            intersects([], { to: 5 }, [], { from: 10 }),
+            intersects([], { ...defaultBounds, to: 5 }, [], { ...defaultBounds, from: 10 }),
             false
         );
     });

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

@@ -229,7 +229,7 @@ describe("suffix()", () => {
                         {
                             type: "boolean",
                             value: true
-                        }
+                        } as any
                     ],
                     true,
                     arg
@@ -249,7 +249,7 @@ describe("suffix()", () => {
             [
                 {
                     key: "id"
-                }
+                } as any
             ],
             true,
             arg

package/libs/dip.ts

@@ -25,7 +25,21 @@ export const includeCollectionConfig = Elabase.includeCollectionConfig
 export const shard_stats = Elabase.shard_stats
 export let config = Elabase.config
 
-export async function insertSync(meta, feature, date, uid, ref, type) {
+
+type DipQuery = Parameters<typeof Elabase.update>[2]
+type DipUpdate = Parameters<typeof Elabase.update>[3]
+
+type IdempotentDip = {
+    new: (meta: Elabase.DipMeta, txn: string, blank?: { blank: boolean }) => Promise<IdempotentDip | false>
+    insert: (collection: string, query: DipQuery, data: DipUpdate) => Promise<void>
+    update: (collection: string, query: DipQuery, data: DipUpdate, rollback?: boolean) => Promise<boolean | number>
+    upsert: (collection: string, query: DipQuery, data: DipUpdate, rollback?: boolean) => Promise<boolean | number>
+    cleanup: (collection: string, query: DipQuery) => Promise<void>
+    finish: () => Promise<unknown>
+}
+
+
+export async function insertSync(meta: Elabase.DipMeta, feature: string, date: number, uid: string, ref: unknown, type: "REMOVE" | "UPSERT") {
     let stamp = new Date(date).toISOString()
     let _id = `${meta.outlet}_${stamp}_${uid}`
     let data = { _id, ref, type: type === "REMOVE" ? type : "UPSERT" }
@@ -33,44 +47,56 @@ export async function insertSync(meta, feature, date, uid, ref, type) {
     await Elabase.insert(meta, collection, data)
 }
 
-export const IdempotentDip = () => {
-    return {
+export const IdempotentDip = (): IdempotentDip => {
+    const state = {
         txn: '',
-        meta: undefined,
-        new: (async function (meta, txn, blank?: {blank: boolean}) {
-            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})
-        })
+        meta: undefined as Elabase.DipMeta | undefined,
+    }
+
+    const idip = {} as IdempotentDip
+
+    idip.new = async function (meta: Elabase.DipMeta, txn: string, blank?: {blank: boolean}) {
+        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
 }
 
+type DipMessage = { meta: {staff: string; user: string}; txn: string; date: number }
+type IdipCleanup = Record<string, string[]> | ((idip: IdempotentDip) => Promise<void>)
 
-export const idip = async (message, callback, cleanup) => {
+export const idip = async (message: {meta: Elabase.DipMeta, txn: string}, callback: (idip: IdempotentDip) => Promise<void>, cleanup: IdipCleanup) => {
     if (!callback)
         throw new Error("Dip.idip() callback argument undefined")
     if (!cleanup)
         throw new Error("Dip.idip() cleanup argument undefined")
-    async function doCleanup(IDip) {
+    async function doCleanup(IDip: IdempotentDip) {
         if (typeof cleanup === 'object') {
             for (let collection in cleanup)
                 await IDip.cleanup(collection, { _id: {$in: cleanup[collection]} })
@@ -81,7 +107,7 @@ export const idip = async (message, callback, cleanup) => {
     let IDip = await IdempotentDip().new(message.meta, message.txn)
     if (!IDip) {
         IDip = await IdempotentDip().new(message.meta, message.txn, {blank: true})
-        await doCleanup(IDip)
+        await doCleanup(IDip as IdempotentDip)
         return
     }
     await callback(IDip)
@@ -90,7 +116,7 @@ export const idip = async (message, callback, cleanup) => {
 }
 
 
-export const insertKeys = (message, meta) => {
+export const insertKeys = (message: DipMessage, meta: Elabase.DipMeta) => {
     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,
@@ -102,7 +128,7 @@ export const insertKeys = (message, meta) => {
         ...(meta?.outlet ? {"outlet": meta.outlet} : {}),
     }
 }
-export const updateKeys = message => {
+export const updateKeys = (message: DipMessage) => {
     return {
         "updated": message.date,
         "updatedBy": message.meta.staff,

package/libs/dipper.ts

@@ -2,7 +2,21 @@
 import axios from 'axios'
 // import {curly} from 'node-libcurl'
 
-function hashStr(str) {
+
+type DipperIdQuery = string | string[] | { $in: string[] }
+
+type DipperArg = {
+    mode: string
+    query?: {
+        _id?: DipperIdQuery
+    }
+    insert?: {
+        _id?: DipperIdQuery
+    }
+    [key: string]: unknown
+}
+
+function hashStr(str: string) {
     let hash = 0;
     for (let i = 0; i < str.length; i++) {
         let charCode = str.charCodeAt(i);
@@ -11,7 +25,7 @@ function hashStr(str) {
     return hash;
 }
 
-function hash(string, digits) {
+function hash(string: string, digits: number) {
     digits = digits || 6;
     var m = Math.pow(10, digits+1) - 1;
     var phi = Math.pow(10, digits) / 2 - 1;
@@ -21,7 +35,7 @@ function hash(string, digits) {
     }
     return n.toString();
 }
-let shards = []
+let shards: string[] = []
 let shardCount = 20
 
 for (let i = 1; i <= shardCount; i++)
@@ -31,13 +45,13 @@ for (let i = 1; i <= shardCount; i++)
 // function shard(key) {
 //     return hash(key,1) % shardCount
 // }
-function shard(key) {
+function shard(key: string) {
     return hashStr(key) % shardCount
 }
 
-export let shard_hits = {}
+export let shard_hits: Record<string, number> = {}
 
-async function postDip(url, arg) {
+async function postDip(url: string | URL, arg: unknown) {
     return (await axios.post(url, arg)).data
   // curl
   // -----
@@ -51,7 +65,7 @@ async function postDip(url, arg) {
 //   return data
 }
 
-export default async function dipper(arg) {
+export default async function dipper(arg: DipperArg) {
 
     let result = []
 
@@ -66,11 +80,12 @@ export default async function dipper(arg) {
 
     } else {
 
-        let ids = typeof _id == "object" ? _id.$in : [_id]
+        type InList = {$in: string[]}
+        let ids = typeof _id == "object" ? (_id as InList).$in : [_id]
         for (let id of ids) {
             let key = shard(id)
             let url = shards[key]
-            shard_hits[url] = (shard_hits[url] ?? 0) + 1
+            shard_hits[url!] = (shard_hits[url!] ?? 0) + 1
             result.push(await postDip(`http://${url}/execute`, arg))
        }
     }
@@ -86,7 +101,7 @@ export default async function dipper(arg) {
 
 export const shard_stats = () => {
     let total: number = (Object.values(shard_hits) as number[]).reduce( (partial: number, value: number) => partial + value, 0)
-    let result = {}
+    let result: Record<string, string> = {}
     Object.entries(shard_hits).forEach( ([key, value]) => result[key] = ((value as number) * 100 / total).toFixed(2) )
     return result
 }

package/libs/elabase.ts

@@ -64,7 +64,7 @@ function deepFreeze(obj) {
     }
     return obj;
 }
-class DipMeta {
+export class DipMeta {
     declare company?: string;
     declare outlet?: string;