corebasic 1.0.211 → 1.0.213

package/dist/libs/utils.js

@@ -0,0 +1,297 @@
+import * as ObjectId from './ObjectId.js';
+import * as Mobile from './mobilecodes.js';
+// Parse JSON file: fileToJson
+import { readFile, writeFile } from 'fs/promises';
+import 'jsonminify';
+// S3 Object Storage
+import { S3Client, ListBucketsCommand, ListObjectsV2Command, GetObjectCommand, PutObjectCommand, CreateBucketCommand, DeleteObjectCommand } from '@aws-sdk/client-s3';
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
+let bucketName = process.env.APP_DEPLOYMENT_NAME ?? ((global?.app?.name ?? "app") + '-dev');
+let _ = (async () => { try {
+    const data = await S3.send(new CreateBucketCommand({ Bucket: bucketName }));
+}
+catch { } })(); // Create Bucket
+export let pipeline = { execute: execute };
+export function log(...args) {
+    let res = [];
+    args.forEach(arg => res.push(typeof arg === "object" ? JSON.stringify(arg, null, '\t') : arg));
+    console.log(...res);
+}
+export function uid() {
+    return ObjectId.ObjectId();
+}
+export function isEmpty(str) {
+    if (!str)
+        return true;
+    return str.match(/\S/) ? false : true; // matches a non space character
+}
+export let GLOBAL_META = { company: "GLOBAL", outlet: "GLOBAL" };
+export function isEmptyJson(json) {
+    for (var i in json)
+        return false;
+    return true;
+}
+export function uniqueObjects(array, key) {
+    // remove duplicates from array of objects with key
+    return [
+        ...new Map(array.map(item => [item[key], item])).values()
+    ];
+}
+// --------------
+// Parse Numbers
+// --------------
+export function parseFloatValue(val) {
+    return parseFloat(val) ? parseFloat(val) : 0;
+}
+export function parseIntValue(val) {
+    return parseInt(val) ? parseInt(val) : 0;
+}
+// ----------------
+// Dates
+// ----------------
+export function now() {
+    return new Date();
+}
+export function toAppDate(date) {
+    if (Object.prototype.toString.call(date) === '[object String]')
+        date = new Date(date);
+    var temp = date;
+    if (isNaN(temp) || date === '')
+        return '';
+    var day = temp.getDate().toString();
+    if (day.length === 1)
+        day = "0" + day;
+    var month = (temp.getMonth() + 1).toString();
+    if (month.length == 1)
+        month = "0" + month;
+    return (day + "/" + month + "/" + temp.getFullYear().toString());
+}
+export function toDate(arg, currentTime) {
+    var st = arg.split('/');
+    var temp = new Date(st[2], parseInt(st[1]) - 1, st[0]);
+    temp.setHours(0);
+    temp.setMinutes(0);
+    temp.setSeconds(0);
+    temp.setMilliseconds(0);
+    if (currentTime) {
+        var curdate = getCurrentDate();
+        temp.setHours(curdate.getHours());
+        temp.setMinutes(curdate.getMinutes());
+        temp.setSeconds(curdate.getSeconds());
+        temp.setMilliseconds(curdate.getMilliseconds());
+    }
+    if (isNaN(temp))
+        return undefined;
+    return temp;
+}
+export function getDatesBetweenTwoDates(start, end) {
+    var arr = [];
+    var dt = new Date(start);
+    dt.setHours(0);
+    dt.setMinutes(0);
+    dt.setSeconds(0);
+    dt.setMilliseconds(0);
+    while (dt <= end) {
+        arr.push(new Date(dt));
+        dt.setDate(dt.getDate() + 1);
+    }
+    return arr;
+}
+export function deepCopy(obj) {
+    if (Object.prototype.toString.call(obj) === '[object Array]') {
+        var out = [], i = 0, len = obj.length;
+        for (; i < len; i++) {
+            if (Object.prototype.toString.call(obj[i]) === '[object Date]')
+                out[i] = new Date(obj[i]);
+            else
+                out[i] = arguments.callee(obj[i]);
+        }
+        return out;
+    }
+    if (typeof obj === 'object') {
+        var out = {}, i;
+        for (i in obj) {
+            if (Object.prototype.toString.call(obj[i]) === '[object Date]')
+                out[i] = new Date(obj[i]);
+            else
+                out[i] = arguments.callee(obj[i]);
+        }
+        return out;
+    }
+    return obj;
+}
+export function formatAMPM(date) {
+    var hours = date.getHours();
+    var minutes = date.getMinutes();
+    var ampm = hours >= 12 ? 'pm' : 'am';
+    hours = hours % 12;
+    hours = hours ? hours : 12; // the hour '0' should be '12'
+    minutes = minutes < 10 ? '0' + minutes : minutes;
+    var strTime = hours + ':' + minutes + ' ' + ampm;
+    return strTime;
+}
+export function sum(array) {
+    var res = 0;
+    for (var i in array)
+        res += parseFloat(array[i]) ? parseFloat(array[i]) : 0;
+    return res;
+}
+export function addMonths(date, monthsToAdd) {
+    const day = date.getDate();
+    date.setMonth(date.getMonth() + monthsToAdd);
+    // If the day rolled over, clamp to last day of target month
+    if (date.getDate() !== day) {
+        date.setDate(0);
+    }
+    return date;
+}
+export function addYears(date, yearsToAdd) {
+    return addMonths(date, yearsToAdd * 12);
+}
+export function addUTCMonths(date, monthsToAdd) {
+    const day = date.getUTCDate();
+    date.setUTCMonth(date.getUTCMonth() + monthsToAdd);
+    // If the day rolled over, clamp to last day of target month
+    if (date.getUTCDate() !== day) {
+        date.setUTCDate(0);
+    }
+    return date;
+}
+export function addUTCYears(date, yearsToAdd) {
+    return addUTCMonths(date, yearsToAdd * 12);
+}
+export function addDays(date, daysToAdd) {
+    date.setDate(date.getDate() + daysToAdd);
+    return date;
+}
+export function addHours(date, hoursToAdd) {
+    date.setHours(date.getHours() + hoursToAdd);
+    return date;
+}
+export function addUTCDays(date, daysToAdd) {
+    date.setUTCDate(date.getUTCDate() + daysToAdd);
+    return date;
+}
+export function addUTCHours(date, hoursToAdd) {
+    date.setUTCHours(date.getUTCHours() + hoursToAdd);
+    return date;
+}
+export function validityToMillisecs(start, validity) {
+    const now = new Date(start);
+    let [count, period] = validity.trim().split(' ').filter(item => item.trim());
+    count = parseIntValue(count);
+    period = period.toLowerCase();
+    const timeline = {
+        year: _ => addYears(now, count),
+        years: _ => addYears(now, count),
+        month: _ => addMonths(now, count),
+        months: _ => addMonths(now, count),
+        day: _ => now.setDate(now.getDate() + count),
+        days: _ => now.setDate(now.getDate() + count),
+        week: _ => now.setDate(now.getDate() + (count * 7)),
+        weeks: _ => now.setDate(now.getDate() + (count * 7)),
+        hour: _ => now.setHours(now.getHours() + count),
+        hours: _ => now.setHours(now.getHours() + count),
+        minute: _ => now.setMinutes(now.getMinutes() + count),
+        minutes: _ => now.setMinutes(now.getMinutes() + count),
+    };
+    timeline[period]();
+    return now.getTime();
+}
+export function validityToUTCMillisecs(start, validity) {
+    const now = new Date(start);
+    let [count, period] = validity.trim().split(' ').filter(item => item.trim());
+    count = parseIntValue(count);
+    period = period.toLowerCase();
+    const timeline = {
+        year: _ => addUTCYears(now, count),
+        years: _ => addUTCYears(now, count),
+        month: _ => addUTCMonths(now, count),
+        months: _ => addUTCMonths(now, count),
+        day: _ => now.setUTCDate(now.getUTCDate() + count),
+        days: _ => now.setUTCDate(now.getUTCDate() + count),
+        week: _ => now.setUTCDate(now.getUTCDate() + (count * 7)),
+        weeks: _ => now.setUTCDate(now.getUTCDate() + (count * 7)),
+        hour: _ => now.setUTCHours(now.getUTCHours() + count),
+        hours: _ => now.setUTCHours(now.getUTCHours() + count),
+        minute: _ => now.setUTCMinutes(now.getUTCMinutes() + count),
+        minutes: _ => now.setUTCMinutes(now.getUTCMinutes() + count),
+    };
+    timeline[period]();
+    return now.getTime();
+}
+// ----------------
+// JSON
+// ----------------
+export async function fileToJson(path, file) {
+    let data = (await readFile(new URL(file, path).toString().replace('file://', ''), 'utf8'));
+    return JSON.parse(JSON.minify(data));
+}
+// ----------------
+// File
+// ----------------
+export async function fileToString(file) {
+    return await readFile(file, 'utf8');
+}
+export async function stringToFile(file, data) {
+    return await writeFile(file, data);
+}
+// ----------------
+// Pipeline Execute
+// ----------------
+function execute(pipeline, errfn) {
+    startPipeline(pipeline, 0, undefined, errfn);
+}
+function startPipeline(pipeline, index, data, errfn) {
+    index = index == undefined ? 0 : index;
+    if (index == pipeline.length)
+        return;
+    pipeline[index](data).then(data => startPipeline(pipeline, index + 1, data)).catch(err => { if (errfn)
+        errfn(err); });
+}
+// -----------------
+// S3 Object Storage
+// -----------------
+export async function getUrl(path, expiry = 3600) {
+    return await getSignedUrl(S3, new GetObjectCommand({ Bucket: bucketName, Key: path }), { expiresIn: expiry });
+}
+export async function putUrl(path, expiry = 3600) {
+    return await getSignedUrl(S3, new PutObjectCommand({ Bucket: bucketName, Key: path }), { expiresIn: expiry });
+}
+// ---------------------------
+// Express Middleware Exclude
+// ---------------------------
+export const excludeMiddleware = function (middleware, ...paths) {
+    return function (req, res, next) {
+        const pathCheck = paths.some(path => {
+            let url = req.path.split('/');
+            let cmp = path.split('/');
+            if (url.length !== cmp.length)
+                return false;
+            let f = cmp.map((p, index) => p.startsWith(":") ? url[index] : p).join('/');
+            return f === req.path;
+        });
+        pathCheck ? next() : middleware(req, res, next);
+    };
+};
+// --------------------
+// Parse Mobile Number
+// --------------------
+export function parseMob(mob, code) {
+    code = code ?? "IN";
+    if (isEmpty(mob))
+        return mob;
+    if (mob.startsWith("MOB_"))
+        return mob;
+    mob = mob.trim().replace(/(,| |-|\+)/g, ''); // remove comma, space, hyphen and plus
+    mob = mob.startsWith("0") ? mob.replace(/^0*/, '') : mob; // remove starting n zeroes
+    let prefix = Mobile.codes[code].phone;
+    if (!mob.startsWith(prefix)) {
+        mob = `${prefix}${mob}`;
+    }
+    else { // mob.startsWith(prefix)
+        if (mob.length < Mobile.codes[code].phoneLength + prefix.length) // mob just happens to start with prefix
+            mob = `${prefix}${mob}`;
+    }
+    return mob;
+}

package/index.ts

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

package/libs/{auth.js → auth.ts}

@@ -1,9 +1,9 @@
 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'
+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) => {

package/libs/{compression.js → compression.ts}

@@ -1,4 +1,4 @@
-import * as Utils from './utils.js'
+import * as Utils from './utils.ts'
 import compression from 'compression'
 
 // Compression Notes

package/libs/dip/suffix/date.ts

@@ -0,0 +1,121 @@
+import {getNormalizedBounds} from './index.ts'
+import {addUTCYears, addUTCMonths, addUTCDays} from '../../utils.ts'
+
+
+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)];
+}
+
+
+

package/libs/dip/suffix/{index.js → index.ts}

@@ -203,8 +203,8 @@ export function extractBounds(values) {
     };
 }
 
-// Converts exclusive bounds ($gt/$lt) into inclusive bounds. Mutates if date type
-export function getNormalizedBounds(bounds_t, type, step) {
+// Converts exclusive bounds ($gt/$lt) into inclusive bounds
+export function getNormalizedBounds(bounds_t, type) {
     let bounds = {...bounds_t}
 
     if (type === "number") {
@@ -213,22 +213,11 @@ export function getNormalizedBounds(bounds_t, type, step) {
         if (bounds.toOp === "$lt")
             bounds.to--;
     } else if (type === "date") {
-        if (step === "day") {
-            if (bounds.fromOp === "$gt")
-                bounds.from.setDate(bounds.from.getDate() + 1);
-            if (bounds.toOp === "$lt")
-                bounds.to.setDate(bounds.to.getDate() - 1);
-        } else if (step === "month") {
-            if (bounds.fromOp === "$gt")
-                bounds.from.setMonth(bounds.from.getMonth() + 1);
-            if (bounds.toOp === "$lt")
-                bounds.to.setMonth(bounds.to.getMonth() - 1);
-        } else {
-            if (bounds.fromOp === "$gt")
-                bounds.from.setFullYear(bounds.from.getFullYear() + 1);
-            if (bounds.toOp === "$lt")
-                bounds.to.setFullYear(bounds.to.getFullYear() - 1);
-        }
+        if (bounds.fromOp === "$gt")
+            bounds.from = new Date(bounds.from.getTime() + 1);
+
+        if (bounds.toOp === "$lt")
+            bounds.to = new Date(bounds.to.getTime() - 1);
     }
 
     return bounds

package/libs/dip/suffix/{policy.js → policy.ts}

@@ -1,5 +1,5 @@
-import {entries, reduceRanges, extractBounds} from './index.js'
-import {suffix} from './suffix.js'
+import {entries, reduceRanges, extractBounds} from './index.ts'
+import {suffix} from './suffix.ts'
 
 
 

package/libs/dip/suffix/{suffix.js → suffix.ts}

@@ -1,5 +1,5 @@
-import {entries, reduceRanges, extractBounds, getNormalizedBounds} from './index.js'
-import {formatDate, fillDates} from './date.js'
+import {entries, reduceRanges, extractBounds, getNormalizedBounds} from './index.ts'
+import {formatDate, fillDates} from './date.ts'
 
 
 

package/libs/dip/suffix/tests/{date.test.js → date.test.ts}

@@ -1,7 +1,7 @@
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
 
-import { formatDate, fillDates } from "../date.js";
+import { formatDate, fillDates } from "../date.ts";
 
 
 describe("formatDate()", () => {

package/libs/dip/suffix/tests/{index.test.js → index.test.ts}

@@ -1,7 +1,7 @@
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
 
-import {reduceRanges, extractBounds} from "../index.js";
+import {reduceRanges, extractBounds} from "../index.ts";
 
 
 

package/libs/dip/suffix/tests/{policy.applySuffixPolicy.test.js → policy.applySuffixPolicy.test.ts}

@@ -1,6 +1,6 @@
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
-import {applySuffixPolicy} from "../policy.js";
+import {applySuffixPolicy} from "../policy.ts";
 
 // -----------------------------------------------------------------------------
 // applySuffixPolicy()

package/libs/dip/suffix/tests/{policy.test.js → policy.test.ts}

@@ -1,6 +1,6 @@
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
-import {matchPolicy, overlaps, contains, intersects, applySuffixPolicy} from "../policy.js";
+import {matchPolicy, overlaps, contains, intersects, applySuffixPolicy} from "../policy.ts";
 
 
 /* ============================================================

package/libs/dip/suffix/tests/{suffix.test.js → suffix.test.ts}

@@ -1,7 +1,7 @@
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
 
-import { suffix } from "../suffix.js";
+import { suffix } from "../suffix.ts";
 
 
 describe("suffix()", () => {

package/libs/{dip.js → dip.ts}

@@ -1,4 +1,4 @@
-import * as Elabase from './elabase.js'
+import * as Elabase from './elabase.ts'
 
 export const start = Elabase.start
 

package/libs/{elabase.js → elabase.ts}

@@ -1,8 +1,8 @@
 import axios from 'axios'
-import {default as dipper, shard_stats as ShardStats} from './dipper.js'
-import * as Utils from './utils.js'
-import * as Cpp from './cpp.js'
-import {applySuffixPolicy} from './dip/suffix/policy.js'
+import {default as dipper, shard_stats as ShardStats} from './dipper.ts'
+import * as Utils from './utils.ts'
+import * as Cpp from './cpp.ts'
+import {applySuffixPolicy} from './dip/suffix/policy.ts'
 
 
 

package/libs/{features.js → features.ts}

@@ -1,8 +1,8 @@
-import * as Dip from './dip.js'
-import * as Kafka from './kafka.js'
-import * as Utils from './utils.js'
-import * as Session from './session.js'
-import * as Messaging from './messaging.js'
+import * as Dip from './dip.ts'
+import * as Kafka from './kafka.ts'
+import * as Utils from './utils.ts'
+import * as Session from './session.ts'
+import * as Messaging from './messaging.ts'
 import axios from 'axios'
 import jwt from 'jsonwebtoken'
 

package/libs/{messaging.js → messaging.ts}

@@ -1,7 +1,7 @@
 
 import axios from 'axios'
 import { createClient } from 'redis';
-import * as Utils from './utils.js'
+import * as Utils from './utils.ts'
 
 const url = process.env.REDIS_URL || "redis://localhost:6380"
 

package/libs/{session.js → session.ts}

@@ -1,6 +1,6 @@
 import jwt from 'jsonwebtoken'
-import * as Utils from './utils.js'
-import * as Features from './features.js'
+import * as Utils from './utils.ts'
+import * as Features from './features.ts'
 let app