corebasic 1.0.212 → 1.0.213

package/dist/index.js

@@ -0,0 +1,10 @@
+import * as Elabase from './libs/elabase.js';
+import * as Dip from './libs/dip.js';
+import * as Kafka from './libs/kafka.js';
+import * as Utils from './libs/utils.js';
+import * as Session from './libs/session.js';
+import * as Auth from './libs/auth.js';
+import * as Features from './libs/features.js';
+import * as Messaging from './libs/messaging.js';
+import * as Compression from './libs/compression.js';
+export { Elabase, Dip, Kafka, Utils, Session, Auth, Features, Messaging, Compression };

package/dist/libs/ObjectId.js

@@ -0,0 +1,114 @@
+/*
+*
+* Copyright (c) 2011-2014- Justin Dearing (zippy1981@gmail.com)
+* Dual licensed under the MIT (http://www.opensource.org/licenses/mit-license.php)
+* and GPL (http://www.opensource.org/licenses/gpl-license.php) version 2 licenses.
+* This software is not distributed under version 3 or later of the GPL.
+*
+* Version 1.0.2
+*
+*/
+if (!document)
+    var document = { cookie: '' }; // fix crashes on node
+/**
+ * Javascript class that mimics how WCF serializes a object of type MongoDB.Bson.ObjectId
+ * and converts between that format and the standard 24 character representation.
+*/
+export var ObjectId = (function () {
+    var increment = Math.floor(Math.random() * (16777216));
+    var pid = Math.floor(Math.random() * (65536));
+    var machine = Math.floor(Math.random() * (16777216));
+    var setMachineCookie = function () {
+        var cookieList = document.cookie.split('; ');
+        for (var i in cookieList) {
+            var cookie = cookieList[i].split('=');
+            var cookieMachineId = parseInt(cookie[1], 10);
+            if (cookie[0] == 'mongoMachineId' && cookieMachineId && cookieMachineId >= 0 && cookieMachineId <= 16777215) {
+                machine = cookieMachineId;
+                break;
+            }
+        }
+        document.cookie = 'mongoMachineId=' + machine + ';expires=Tue, 19 Jan 2038 05:00:00 GMT;path=/';
+    };
+    if (typeof (localStorage) != 'undefined') {
+        try {
+            var mongoMachineId = parseInt(localStorage['mongoMachineId']);
+            if (mongoMachineId >= 0 && mongoMachineId <= 16777215) {
+                machine = Math.floor(localStorage['mongoMachineId']);
+            }
+            // Just always stick the value in.
+            localStorage['mongoMachineId'] = machine;
+        }
+        catch (e) {
+            setMachineCookie();
+        }
+    }
+    else {
+        setMachineCookie();
+    }
+    function ObjId() {
+        if (!(this instanceof ObjectId)) {
+            return new ObjectId(arguments[0], arguments[1], arguments[2], arguments[3]).toString();
+        }
+        if (typeof (arguments[0]) == 'object') {
+            this.timestamp = arguments[0].timestamp;
+            this.machine = arguments[0].machine;
+            this.pid = arguments[0].pid;
+            this.increment = arguments[0].increment;
+        }
+        else if (typeof (arguments[0]) == 'string' && arguments[0].length == 24) {
+            this.timestamp = Number('0x' + arguments[0].substr(0, 8)),
+                this.machine = Number('0x' + arguments[0].substr(8, 6)),
+                this.pid = Number('0x' + arguments[0].substr(14, 4)),
+                this.increment = Number('0x' + arguments[0].substr(18, 6));
+        }
+        else if (arguments.length == 4 && arguments[0] != null) {
+            this.timestamp = arguments[0];
+            this.machine = arguments[1];
+            this.pid = arguments[2];
+            this.increment = arguments[3];
+        }
+        else {
+            this.timestamp = Math.floor(new Date().valueOf() / 1000);
+            this.machine = machine;
+            this.pid = pid;
+            this.increment = increment++;
+            if (increment > 0xffffff) {
+                increment = 0;
+            }
+        }
+    }
+    ;
+    return ObjId;
+})();
+ObjectId.prototype.getDate = function () {
+    return new Date(this.timestamp * 1000);
+};
+ObjectId.prototype.toArray = function () {
+    var strOid = this.toString();
+    var array = [];
+    var i;
+    for (i = 0; i < 12; i++) {
+        array[i] = parseInt(strOid.slice(i * 2, i * 2 + 2), 16);
+    }
+    return array;
+};
+/**
+* Turns a WCF representation of a BSON ObjectId into a 24 character string representation.
+*/
+ObjectId.prototype.toString = function () {
+    if (this.timestamp === undefined
+        || this.machine === undefined
+        || this.pid === undefined
+        || this.increment === undefined) {
+        return 'Invalid ObjectId';
+    }
+    var timestamp = this.timestamp.toString(16);
+    var machine = this.machine.toString(16);
+    var pid = this.pid.toString(16);
+    var increment = this.increment.toString(16);
+    return '00000000'.substr(0, 8 - timestamp.length) + timestamp +
+        '000000'.substr(0, 6 - machine.length) + machine +
+        '0000'.substr(0, 4 - pid.length) + pid +
+        '000000'.substr(0, 6 - increment.length) + increment;
+};

package/dist/libs/auth.js

@@ -0,0 +1,103 @@
+import axios from 'axios';
+import otpGenerator from 'otp-generator';
+import * as Dip from './dip.js';
+import * as Utils from './utils.js';
+import * as Session from './session.js';
+let validateFn, validateErrMessage;
+export const validate = (callback, errMessage) => {
+    validateFn = callback;
+};
+export const start = (app, 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' });
+            return;
+        }
+        try {
+            let login = await attemptLogin(req, res);
+            if (login.mode === 'verify' && login.success) {
+                let tokens = Session.generateAccessToken(login.userId, req.body.clientId);
+                let response = { ...login, tokens };
+                if (successCallback)
+                    await successCallback(req, res, response);
+                else
+                    res.json(response);
+            }
+            else
+                res.json(login);
+        }
+        catch (err) {
+            return res.status(401).json(err);
+        }
+    });
+};
+async function attemptLogin(req, res) {
+    let meta = { company: "GLOBAL", outlet: "GLOBAL" };
+    let expiry = 300000;
+    let userMob = req.body.mob ?? req.body.phone;
+    let mob = userMob.endsWith('123456789') ? '0123456789' : Utils.parseMob(userMob);
+    let time = new Date().getTime();
+    let collection = (req.body.app ? req.body.app + '.' : '') + "auth.login";
+    let errMessage = { success: false, message: "Login Server Error" };
+    let otpValid = Utils.isEmpty(req.body.otp) ? false : true;
+    let clientId = req.body.clientId;
+    if (Utils.isEmpty(clientId))
+        throw { ...errMessage, mode: otpValid ? 'verify' : 'login', info: "Invalid Client ID" };
+    if (otpValid) { // verify login
+        let res = await Dip.query(meta, collection, { _id: mob, otp: req.body.otp, clientId, time: { $gt: time - expiry } });
+        if (res.length) {
+            try {
+                await Dip.update(meta, collection, { _id: mob }, { $set: { otp: '', clientId: '', loggedIn: true } });
+            }
+            catch (err) {
+                throw { ...errMessage, mode: 'verify', info: 'Cleanup Failed' };
+            }
+            return { ...res[0], mode: 'verify', success: true, userId: res[0].userId, phone: res[0]._id, mob: res[0]._id };
+        }
+        throw { ...errMessage, mode: 'verify', info: "Invalid/Expired OTP" };
+    }
+    else { // generate login
+        let otp = mob === '0123456789' ? '1234' : otpGenerator.generate(4, { upperCaseAlphabets: false, specialChars: false, digital: true, lowerCaseAlphabets: false });
+        if (mob === '0123456789' || await sendOtp(mob, otp, req.body.app, req.body.hash)) {
+            let userId = req.body.userId ?? Utils.uid();
+            let now = Utils.now().getTime();
+            let data = req.body.data ?? {};
+            let info = { clientId, created: now, updated: now, ...data };
+            await Dip.update(meta, collection, { _id: mob }, { $set: { otp, clientId, time, updated: now, attemptLogin: true }, $setOnInsert: { _id: mob, otp, time, userId, ...info } }, { upsert: true });
+            return { mode: 'login', success: true, userId, expiry, phone: mob, mob };
+        }
+        throw { ...errMessage, mode: 'login', info: 'Generating Info Failed' };
+    }
+}
+async function sendOtp(mob, otp, app, hash) {
+    if (process.env.LOGIN_OTP_DISABLE) {
+        console.log(otp);
+        return true;
+    }
+    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');
+        await axios.get(api);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// API
+// ----
+// Login =>  HttpRequest.post('/login').send({app: '', mob: '', userId: 'Optional', data: {//optional} }) // Response => { mode: 'login', success, userId, expiry }
+// Verify => HttpRequest.post('/login').send({app: '', clientId: '', mob: '', otp: ''})             // Response => { mode: 'verify', success, userId }
+// Usage
+// Auth.validate((req) => ["Phone1", "Phone2"].includes(req.body.mob.trim()))
+// Auth.start(app, async (req, res, data) => {
+//     try {
+//         let meta = {company: "GLOBAL", outlet: "GLOBAL"}
+//         await Dip.insert(meta, "users", {  }, "asdsds")
+//         await Kafka.send("users", {event: "userLogin", ...data, time: Utils.now()})
+//         res.json(data)
+//     } catch {
+//         res.json({...data, success: false})
+//     }
+// })

package/dist/libs/compression.js

@@ -0,0 +1,11 @@
+import * as Utils from './utils.js';
+import compression from 'compression';
+// Compression Notes
+// -----------------
+// Default compression gzip. Compressed server responses will have header set with `Content-Encoding: gzip` before sending to client
+// Curl cpr library by default announces compression capability by specifying header `Accept-Encoding`. Meaning client is able to decompress compressed response. Then server can compress responses if needed
+// 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 => {
+    app.use(Utils.excludeMiddleware(compression({ threshold: 1024 }))); // Response above 1024 bytes should be compressed. Default is also 1KB
+};

package/dist/libs/cpp.js

@@ -0,0 +1,154 @@
+import crypto from 'node:crypto';
+function readContent(buffer, valueRef, bytesRef) {
+    const MASK = 0x7F;
+    const MSB = 0x80;
+    const MAX_VLQ_BYTES = 10;
+    // Ensure we have a valid Uint8Array view
+    if (!buffer)
+        return false;
+    const view = ArrayBuffer.isView(buffer) ? buffer : new Uint8Array(buffer);
+    const bufferSize = view.length;
+    let length = 0n;
+    let shift = 0n;
+    let lenBytes = 0;
+    while (true) {
+        if (lenBytes >= MAX_VLQ_BYTES || lenBytes >= bufferSize) {
+            return false;
+        }
+        const byte = view[lenBytes];
+        lenBytes++;
+        length |= BigInt(byte & MASK) << shift;
+        shift += 7n;
+        if ((byte & MSB) === 0) {
+            break;
+        }
+    }
+    // Emulate C++ pointer assignment by modifying the wrapper objects
+    valueRef.value = length;
+    bytesRef.value = lenBytes;
+    return true;
+}
+export function vlqToUint64(arrayBuffer) {
+    // Objects act as containers to simulate C++ pointers/references
+    const valueRef = { value: 0n };
+    const bytesRef = { value: 0 };
+    const success = readContent(arrayBuffer, valueRef, bytesRef);
+    // If read_content returned false, handle or return empty/default values
+    if (!success) {
+        return { value: Number(0n), bytes: 0 };
+    }
+    // Returns a plain object, the equivalent of QVariantMap
+    return {
+        value: Number(valueRef.value), // BigInt to Number
+        bytes: bytesRef.value // Number
+    };
+}
+function writeVlqcontent(buffer, value) {
+    const MASK = 0x7fn;
+    const MSB = 0x80;
+    let bufferPtr = 0;
+    let tempValue = BigInt(value);
+    do {
+        let byte = Number(tempValue & MASK);
+        tempValue >>= 7n;
+        if (tempValue > 0n) {
+            byte |= MSB;
+        }
+        buffer[bufferPtr++] = byte;
+    } while (tempValue > 0n);
+    return bufferPtr;
+}
+export function uint64ToVlq(value) {
+    // 10 bytes is the maximum VLQ size for a uint64
+    const out = Buffer.allocUnsafe(10);
+    const size = writeVlqcontent(out, value);
+    // Returns a fresh, correctly sized buffer copy
+    return Buffer.from(out.subarray(0, size));
+}
+export function sliceArrayBuffer(buffer, offset, length) {
+    // Ensure we are working with a Node.js Buffer
+    const buf = Buffer.isBuffer(buffer) ? buffer : Buffer.from(buffer);
+    const totalSize = buf.length;
+    // Boundary check matching your C++ logic
+    if (offset < 0 || offset >= totalSize) {
+        return Buffer.alloc(0); // Returns an empty Buffer (like QByteArray())
+    }
+    // FIX: If length is -1, automatically calculate the remaining size to the end
+    if (length <= 0 || offset + length > totalSize) {
+        length = totalSize - offset;
+    }
+    // subarray() creates a zero-copy/shallow view over the original memory.
+    // Note: second argument is end index instead of cpp length
+    return buf.subarray(offset, offset + length); // COW/Shallow copy I hope or else what is the use of this function
+}
+export function stringToUtf8ArrayBuffer(arg) {
+    // Converts the string into a Node.js Buffer encoded in UTF-8
+    return Buffer.from(arg, 'utf8');
+}
+export function numberToSortableBytes(value) {
+    // 1. Create an 8-byte buffer and a data view to read/write raw bits
+    const buffer = Buffer.alloc(8);
+    const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    // 2. Write the double value into the buffer to extract its raw 64-bit bits
+    view.setFloat64(0, value, true); // Use little-endian for direct memory mapping
+    let bits = view.getBigUint64(0, true);
+    const SIGN_MASK = 0x8000000000000000n; // Use BigInt literal for 64-bit mask
+    // 3. Apply the sorting transformation logic
+    if ((bits & SIGN_MASK) !== 0n) {
+        // Negative: invert all bits
+        bits = ~bits;
+    }
+    else {
+        // Positive: flip the sign bit
+        bits ^= SIGN_MASK;
+    }
+    // 4. Write the transformed bits back as Big Endian (equivalent to qToBigEndian)
+    view.setBigUint64(0, bits, false); // false = Big Endian
+    return buffer;
+}
+export function defaultHash(buffer) {
+    const buf = Buffer.isBuffer(buffer) ? buffer : Buffer.from(buffer);
+    // Uses the high-speed, non-cryptographic xxhash64 algorithm
+    // supported natively in both Node.js and Bun's crypto module layers.
+    const hashBytes = crypto.createHash('md5').update(buf).digest(); // Earlier used xxhash64 but not available in my openssl. so md5
+    // Reads the 8-byte hash output into a 64-bit BigInt (quint64)
+    return hashBytes.readBigUInt64BE(0);
+}
+export function memcmpEqual(buffer1, buffer2) {
+    const b1 = Buffer.isBuffer(buffer1) ? buffer1 : Buffer.from(buffer1);
+    const b2 = Buffer.isBuffer(buffer2) ? buffer2 : Buffer.from(buffer2);
+    return b1.equals(b2);
+}
+export function arrayBufferToString(buffer) {
+    const buf = Buffer.isBuffer(buffer) ? buffer : Buffer.from(buffer);
+    // Decodes the buffer bytes as a UTF-8 JavaScript string
+    return buf.toString('utf8');
+}
+// Matches QString Response::getSliceAsText
+export function getSliceAsText(rawTextBuffer, offset, length) {
+    // Reuses the identical slice boundary logic from above
+    try {
+        const slice = getSliceAsArrayBuffer(rawTextBuffer, offset, length);
+        // Returns an empty string if slice was invalid, or the decoded UTF-8 string
+        return slice.length === 0 ? "" : slice.toString('utf8');
+    }
+    catch (e) {
+        console.log(e);
+        throw e;
+    }
+}
+// Matches QByteArray Response::getSliceAsArrayBuffer
+export function getSliceAsArrayBuffer(rawTextBuffer, offset, length) {
+    const totalSize = rawTextBuffer.length;
+    if (offset < 0 || offset >= totalSize) {
+        return Buffer.alloc(0);
+    }
+    if (length === -1) {
+        length = totalSize - offset;
+    }
+    else if (length <= 0 || (offset + length) > totalSize) {
+        return Buffer.alloc(0); // Strict failure rule matching your new C++ code
+    }
+    // Creates a zero-copy view of the sliced buffer
+    return rawTextBuffer.subarray(offset, offset + length);
+}

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

@@ -0,0 +1,89 @@
+import { getNormalizedBounds } from './index.js';
+import { addUTCYears, addUTCMonths, addUTCDays } from '../../utils.js';
+const MONTH_SHORT = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+const MONTH_LONG = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
+export function formatDate(value, format) {
+    const dateObj = value instanceof Date ? value : new Date(value);
+    if (Number.isNaN(dateObj.getTime()))
+        throw new Error(`Error: Invalid date: ${value} in suffix policy specified for key in Dip`);
+    const utcMs = dateObj.getTime();
+    // Constant millisecond values for the extreme timezone edges
+    const TWELVE_HOURS_MS = 43200000; // 12 * 60 * 60 * 1000
+    const FOURTEEN_HOURS_MS = 50400000; // 14 * 60 * 60 * 1000
+    // Create dates for the absolute furthest west, UTC, and furthest east
+    const dWest = new Date(utcMs - TWELVE_HOURS_MS);
+    const dEast = new Date(utcMs + FOURTEEN_HOURS_MS);
+    // Extract individual components using UTC methods
+    const y1 = dWest.getUTCFullYear(), m1 = dWest.getUTCMonth(), d1 = dWest.getUTCDate();
+    const y2 = dateObj.getUTCFullYear(), m2 = dateObj.getUTCMonth(), d2 = dateObj.getUTCDate();
+    const y3 = dEast.getUTCFullYear(), m3 = dEast.getUTCMonth(), d3 = dEast.getUTCDate();
+    // Fast, loop-free deduplication using inline conditions
+    const years = [y1];
+    if (y2 !== y1)
+        years.push(y2);
+    if (y3 !== y2 && y3 !== y1)
+        years.push(y3);
+    const months = [m1];
+    if (m2 !== m1)
+        months.push(m2);
+    if (m3 !== m2 && m3 !== m1)
+        months.push(m3);
+    const dates = [d1];
+    if (d2 !== d1)
+        dates.push(d2);
+    if (d3 !== d2 && d3 !== d1)
+        dates.push(d3);
+    // years and months and dates are already deduplicated
+    const separator = '|';
+    const replacements = {
+        YYYY: _ => years.join(separator),
+        YY: _ => years.map(y => String(y).slice(-2)).join(separator),
+        MMMM: _ => months.map(m => MONTH_LONG[m]).join(separator),
+        MMM: _ => months.map(m => MONTH_SHORT[m]).join(separator),
+        MM: _ => months.map(m => String(m + 1).padStart(2, "0")).join(separator),
+        DD: _ => dates.map(d => String(d).padStart(2, "0")).join(separator),
+        D: _ => dates.join(separator),
+    };
+    return format.replace(/YYYY|MMMM|MMM|YY|MM|DD|D/g, token => replacements[token]());
+}
+// 📋 Supported Formats
+// YYYY: 4-digit year (e.g., 2026)
+// YY: 2-digit year (e.g., 26)
+// MMMM: Full month name (e.g., July)
+// MMM: Short month name (e.g., Jul)
+// MM: 2-digit padded month (e.g., 07)
+// DD: 2-digit padded day (e.g., 09)
+// D: Unpadded day (e.g., 9)
+// // let a = new Date()
+// // let a = "2026-11-1"
+// let a = new Date().getTime()
+// let b = formatDate(a, "YYYY/DD-MMMM")
+// console.log(b)
+//
+export function fillDates(bounds_t, format) {
+    const result = [];
+    let step;
+    if (format.includes("D"))
+        step = "day";
+    else if (format.includes("M"))
+        step = "month";
+    else
+        step = "year";
+    let bounds = { ...bounds_t, from: new Date(bounds_t.from), to: new Date(bounds_t.to) };
+    bounds = getNormalizedBounds(bounds, "date");
+    while (bounds.from <= bounds.to) {
+        result.push(formatDate(bounds.from, format));
+        switch (step) {
+            case "day":
+                addUTCDays(bounds.from, 1);
+                break;
+            case "month":
+                addUTCMonths(bounds.from, 1);
+                break;
+            case "year":
+                addUTCYears(bounds.from, 1);
+                break;
+        }
+    }
+    return [...new Set(result)];
+}