corebasic 1.0.230 → 1.0.231

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

@@ -28,34 +28,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 +95,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);

package/dist/libs/kafka.js

@@ -2,7 +2,9 @@
 import { Kafka, logLevel as KafkaLogLevel, CompressionTypes as KafkaCompressionTypes } from 'kafkajs';
 export const logLevel = KafkaLogLevel;
 export const CompressionTypes = KafkaCompressionTypes;
-let kafka, producer, admin;
+let kafka;
+let producer;
+let admin;
 let appName;
 let topicPrefix = '';
 export const start = (arg) => {
@@ -37,16 +39,17 @@ const start_consumer = async function (topic, groupId, callback) {
     consumers.push(consumer);
     await consumer.connect();
     await consumer.subscribe({ topic: topic, fromBeginning: true });
+    const fn = callback;
     await consumer.run({
         autoCommit: false,
         eachMessage: async ({ topic, partition, message }) => {
-            // callback(topic, message.value.toString(), partition) // toString() returns array so won't parse if json.
+            // fn(topic, message.value.toString(), partition) // toString() returns array so won't parse if json.
             let success;
             try {
-                success = await callback(topic, JSON.parse(message.value), partition);
+                success = await fn(topic, JSON.parse(message.value), partition);
             }
             catch (ex) {
-                success = await callback(topic, message.value, partition);
+                success = await fn(topic, message.value, partition);
             }
             await consumer.commitOffsets([{ topic, partition, offset: (Number(message.offset) + 1).toString() }]);
         },

package/dist/libs/messaging.js

@@ -4,14 +4,17 @@ import axios from 'axios';
 // @ts-ignore
 import { createClient } from 'redis';
 const url = process.env.REDIS_URL || "redis://localhost:6380";
-// url: 'redis://alice:foobared@localhost:6380'
-let consumer, publisher;
+let consumer;
+let publisher;
 let users_pool = {};
 async function disconnect(user, uid) {
     if (!users_pool[user])
         return;
-    let [{ res }] = users_pool[user].reqres.filter(item => item.uid === uid).concat([{}]);
-    res.end();
+    let res_items = users_pool[user].reqres.filter(item => item.uid === uid);
+    if (res_items) {
+        const res = res_items[0].res;
+        res.end();
+    }
     if (users_pool[user].listeners[uid]) {
         if (users_pool[user].listeners.count == 1)
             await consumer.unsubscribe(user, users_pool[user].listeners[uid]);

package/dist/libs/session.js

@@ -8,7 +8,7 @@ const REFRESH_TOKEN_SECRET = process.env.JWT_REFRESH_TOKEN_SECRET || "MY_SECRET_
 const DEPLOY_TOKEN_SECRET = process.env.DEPLOY_TOKEN_SECRET || "MY_SECRET_DEPLOY_TOKEN";
 const NDCURVE_DEVELOPER_LICENSE_ACCESS_TOKEN_SECRET = process.env.NDCURVE_DEVELOPER_LICENSE_ACCESS_TOKEN_PUBLIC_KEY;
 let urlsAllowed = [];
-export var ALLOWED_URLS = [];
+export let ALLOWED_URLS = [];
 export const start = (expressApp, allowedUrls) => {
     urlsAllowed = ["/refreshToken", "/login"].concat(allowedUrls ?? []);
     ALLOWED_URLS = urlsAllowed;
@@ -54,7 +54,7 @@ export const start = (expressApp, allowedUrls) => {
             throw null;
         }
         catch (error) {
-            return res.status(401).json({ message: error?.message === "Access Denied" ? error.message : 'Unauthorized' });
+            res.status(401).json({ message: error?.message === "Access Denied" ? "Access Denied" : 'Unauthorized' });
         }
     });
     app.post("/refreshToken", (req, res) => {

package/libs/auth.ts

@@ -7,12 +7,51 @@ import * as Dip from './dip.ts'
 import * as Utils from './utils.ts'
 import * as Session from './session.ts'
 
-let validateFn, validateErrMessage
-export const validate = (callback, errMessage) => {
+
+type AuthRequest = {
+    body: {
+        mob?: string
+        phone?: string
+        code?: string
+        otp?: string
+        clientId?: string
+        app?: string
+        hash?: string
+        userId?: string
+        data?: Record<string, unknown>
+    }
+}
+
+type AuthResponse = {
+    status: (code: number) => AuthResponse
+    json: (body: unknown) => void
+}
+
+type AuthApp = {
+    post: (
+        path: string,
+        handler: (req: AuthRequest, res: AuthResponse) => Promise<void>
+    ) => void
+}
+
+type ValidateFunction = (req: AuthRequest) => boolean
+
+type SuccessCallback = (
+    req: AuthRequest,
+    res: AuthResponse,
+    data: Record<string, unknown>
+) => void | Promise<void>
+
+
+
+let validateFn: ValidateFunction | undefined
+let validateErrMessage: string | undefined
+
+export const validate = (callback: ValidateFunction, errMessage?: string) => {
     validateFn = callback
 }
 
-export const start = (app, successCallback) => {
+export const start = (app: AuthApp, successCallback?: SuccessCallback) => {
     app.post("/login", async (req, res) => {
         if (validateFn && !validateFn(req)) {
             res.status(401).json({ mode: 'login', success: false, info: validateErrMessage ?? 'Validation Failed', message: 'Login Server Error' })
@@ -21,7 +60,7 @@ export const start = (app, successCallback) => {
         try {
             let login = await attemptLogin(req, res)
             if (login.mode === 'verify' && login.success) {
-                let tokens = Session.generateAccessToken(login.userId, req.body.clientId)
+                let tokens = Session.generateAccessToken(login.userId, req.body.clientId ?? '')
                 let response = {...login, tokens}
                 if (successCallback)
                     await successCallback(req, res, response)
@@ -35,12 +74,12 @@ export const start = (app, successCallback) => {
     })
 }
 
-async function attemptLogin(req, res) {
+async function attemptLogin(req: AuthRequest, res: AuthResponse) {
     let meta = {company: "GLOBAL", outlet: "GLOBAL"}
 
     let expiry = 300000
-    let userMob = req.body.mob ?? req.body.phone
-    const code = req.body.code
+    let userMob = req.body.mob ?? req.body.phone ?? ''
+    const code = req.body.code ?? ''
     let mob = userMob.endsWith('123456789') ? '0123456789' : Utils.parseMob(userMob, code)
     let time = new Date().getTime()
     let collection = (req.body.app ? req.body.app + '.' : '') + "auth.login"
@@ -73,7 +112,7 @@ async function attemptLogin(req, res) {
 }
 
 
-async function sendOtp(mob, otp, app, hash) {
+async function sendOtp(mob: string, otp: string, app?: string, hash?: string) {
     if (process.env.LOGIN_OTP_DISABLE) {
         console.log(otp);
         return true
@@ -81,7 +120,7 @@ async function sendOtp(mob, otp, app, hash) {
     try {
         if (app && hash)
             app = encodeURIComponent(`${app} (#${hash})`) // Of the form '<app> (#<hash>)' for better readability. Note: Axios works with SlypBusiness%20(%23<HASH>) but Curl requires SlypBusiness%20%28%23<HASH>%29
-        let api = process.env.SMS_API.replace(':phone', mob).replace(':otp', otp).replace(':app', app ?? 'app')
+        let api = process.env.SMS_API!.replace(':phone', mob).replace(':otp', otp).replace(':app', app ?? 'app')
         await axios.get(api)
         return true
     } catch {

package/libs/compression.ts

@@ -9,6 +9,11 @@ import compression from 'compression'
 // Regarding Client compressing data send to server, I think if server has `Content-Encoding: gzip` set, then client might compress before sending. But not sure. Need to check.
 // Http Stream or ServerSideEvents require res.flush() after res.write(). res.flush function is added by the express compression middleware
 
-export const start = app => {
+
+type ExpressApp = {
+    use: (fn: unknown) => unknown
+}
+
+export const start = (app: ExpressApp) => {
     app.use(Utils.excludeMiddleware(compression({threshold: 1024}))) // Response above 1024 bytes should be compressed. Default is also 1KB
 }