corebasic 1.0.230 → 1.0.232

package/dist/libs/features.js

@@ -16,10 +16,13 @@ import axios from 'axios';
 // @ts-ignore
 import jwt from 'jsonwebtoken';
 let features = {};
-let apis = {};
-const getFeatureMethod = api => api.split(' ')[0].toLowerCase();
-const getFeatureUrl = api => api.split(' ')[1];
-const getFeature = name => features[name];
+let apis = {
+// <api>: {<feature>: FeatureEntry}
+};
+const getFeatureMethod = (api) => api.split(' ')[0].toLowerCase();
+const getFeatureUrl = (api) => { const url = api.split(' ')[1]; if (!url)
+    throw new Error(`Invalid Feature url in api: ${api}`); return url; };
+const getFeature = (name) => features[name];
 const DEPLOY_TOKEN_SECRET = process.env.DEPLOY_TOKEN_SECRET || "MY_SECRET_DEPLOY_TOKEN";
 const SERVICE_ACCESS_TOKEN = jwt.sign({ app: process.env.APP_DEPLOYMENT_NAME }, DEPLOY_TOKEN_SECRET, { expiresIn: '365d' });
 const NDCURVE_DEVELOPER_LICENSE_ACCESS_TOKEN = await (async () => { if (process.env.NDCURVE_DEVELOPER_SERVICE)
@@ -50,7 +53,7 @@ async function loadLocalFeatures() {
 let SLYP_FEATURES_LIST = await loadLocalFeatures();
 let appId = Utils.uid();
 let SERVICE_ADDRESS = process.env.APP_ENDPOINT || 'http://127.0.0.1:3000';
-export const get = feature => {
+export const get = (feature) => {
     const throwError = () => { throw new Error(`Feature ${feature} not found in internal or external list during Features.subscribe call`); };
     const baseFeature = getFeature(feature);
     let { api, service = SERVICE_ADDRESS, topic } = baseFeature ? baseFeature : (SLYP_FEATURES_LIST[feature] ?? throwError());
@@ -68,16 +71,27 @@ export const send = async (meta, feature, data, params) => {
         if (url.includes(':'))
             throw new Error(`Error: Internal feature call send on feature: ${feature} when api/params/substitution`);
     }
-    let payload = { ...meta, data, feature, txn: Utils.uid() };
+    const payload = { ...meta, data, feature, txn: Utils.uid() };
     service = service.replace('http://slyp.app', 'https://slyp.app');
     // return  (await axios[method](`${service}${url}`, { data: payload, headers: {jwt: headers.jwt}, timeout: 1000 })).data
     // Used to work. But request to 127.0.0.1 fails to send the specified headers along with the request.
     // return  (await axios[method](`${service}${url}`, payload, {headers: {jwt: SERVICE_ACCESS_TOKEN, service: true}, timeout: 1000 })).data // Worked Earlier, but issue spotted
-    if (getFeature(feature)) { // Local call
+    if (baseFeature) { // Local call
         let response;
-        let req = { meta, body: payload, params, method };
+        let req = { body: payload, params: params ?? {}, method, path: url, url: '' };
         req = JSON.parse(JSON.stringify(req));
-        let res = { json: payload => response = payload, end: () => true };
+        const callback = (payload) => { response = payload; };
+        const res = {
+            json: callback,
+            send: callback,
+            end: () => { },
+            status: (_status) => { return { send: callback, json: callback }; },
+            sendStatus: (_status) => { },
+            setHeader: (_header, _value) => { },
+            flushHeaders: () => { },
+            headersSent: false,
+            writableEnded: false,
+        };
         await apiHandler(req, res);
         return response;
     }
@@ -109,7 +123,8 @@ async function announce() {
 function getFeaturelessFeature(req) {
     if (Session.ALLOWED_URLS.includes(req.path)) {
         for (let key in features) {
-            if (features[key].featureless && features[key].api === req.method.toUpperCase() + ' ' + req.path) {
+            const feature = features[key];
+            if (feature.featureless && feature.api === req.method.toUpperCase() + ' ' + req.path) {
                 return getFeature(key);
             }
         }
@@ -129,44 +144,77 @@ const apiHandler = async (req, res) => {
             console.warn(`Feature: ${req.body.feature} not available`);
             throw { status: 404, message: `Resource not found. Feature ${req.body.feature} not available.` };
         }
+        feature = feature; // typescript validation with !
         let topic = feature.topic;
-        let params = getFeatureUrl(feature.api).split("/").filter(item => item.startsWith(":")).map(item => item.replace(":", ""));
+        let params = getFeatureUrl(feature.api).split("/").filter((item) => item.startsWith(":")).map((item) => item.replace(":", ""));
         for (let param of params)
             if (!req.params[param])
                 throw { status: 404, message: "Resource not found. One or more url parameter not specified." };
-        let meta = { ...req.body, data: undefined };
-        req.meta = meta;
+        let meta = { ...req.body, data: undefined }; // TODO: Must also include invoiceTxn
         if (process.env.USE_DEFAULT_COMPANY) {
-            req.meta.company = 'DEFAULT_COMPANY';
-            req.meta.outlet = 'DEFAULT_OUTLET';
+            meta.company = 'DEFAULT_COMPANY';
+            meta.outlet = 'DEFAULT_OUTLET';
         }
+        meta.txn = meta.txn ?? Utils.uid();
+        const message = {
+            meta,
+            data: req.body.data,
+            params: req.params,
+            // To be removed 1
+            date: new Date().getTime(),
+            // To be removed 2
+            topic,
+            feature: req.body.feature,
+            user: req.body.user,
+            txn: meta.txn,
+        };
+        const appReq = {
+            meta: message.meta,
+            body: message,
+            params: message.params,
+            method: method,
+            path: req.path,
+            url: req.url,
+            headers: req.headers,
+            query: req.query,
+            on: req.on,
+        };
+        const appRes = res;
         if (method === "get") {
             try {
-                req.body = { ...req.body, topic };
-                await feature.handler(req, res);
+                // await feature.handler({...req, headers: req.headers, body: {...req.body, topic} }, res)
+                // req.body = {...req.body, topic}
+                await feature.handler(appReq, appRes);
             }
             catch (err) {
                 if (process.env.DEBUG_MODE)
-                    console.log('Error: Feature: ', req.body?.feature ?? (featureless ? `Featureless Api:${featureless.api}` : undefined), err);
+                    console.error('Error: Feature: ', req.body?.feature ?? (featureless ? `Featureless Api:${featureless.api}` : undefined), err);
                 throw { status: 500, message: "Failed to GET feature", ...err };
             }
         }
         else if (method !== "get" && feature.bypass) {
             try {
-                await feature.handler(topic, prepareMessage(req), req, res);
+                await feature.handler(topic, message, appReq, appRes);
             }
             catch (err) {
                 if (process.env.DEBUG_MODE)
-                    console.log('Error: Feature: ', req.body?.feature ?? (featureless ? `Featureless Api:${featureless.api}` : undefined), err);
+                    console.error('Error: Feature: ', req.body?.feature ?? (featureless ? `Featureless Api:${featureless.api}` : undefined), err);
                 throw { status: 500, message: "Failed to POST feature", ...err };
             }
         }
-        else
-            await commandAction(req, res, topic);
+        else {
+            try {
+                await Kafka.send(`Features.${topic}`, message, message.user, { compression: Kafka.CompressionTypes.GZIP });
+            }
+            catch {
+                throw { status: 500, message: "Failed to queue the transaction" };
+            }
+            appRes.json({ data: { txn: message.txn, success: true, status: "Queued", featureQueued: true } });
+        }
     }
     catch (err) {
         if (process.env.DEBUG_MODE)
-            console.log('Error: Feature: ', req.body?.feature ?? (featureless ? `Featureless Api:${featureless.api}` : undefined), err);
+            console.error('Error: Feature: ', req.body?.feature ?? (featureless ? `Featureless Api:${featureless.api}` : undefined), err);
         try { // Sometimes error occurs when disconnecting stream from front end
             res.status(err.status ?? 500).json(err);
         }
@@ -203,6 +251,8 @@ function registerApi() {
     for (let api in apis) {
         let method = getFeatureMethod(api);
         let url = api.split(' ')[1];
+        if (!url)
+            throw new Error(`No url path found in api ${api} during Features.registerApi()`);
         if (api === 'GET /transactions/:id')
             continue;
         ExpressApp[method](url, apiHandler);
@@ -219,10 +269,10 @@ export const start = async (app, url, file) => {
     app.get('/features', async (req, res) => {
         let exp_features = {};
         for (let [key, { api }] of Object.entries(features))
-            exp_features[key] = { api, service: `${SERVICE_ADDRESS}` };
+            exp_features[key] = { api, service: `${SERVICE_ADDRESS}`, subscribe: '', topic: '' };
         if (process.env.LOAD_LOCAL_FEATURES) {
             for (let key in SLYP_FEATURES_LIST)
-                SLYP_FEATURES_LIST[key].headers = { JWT: SERVICE_ACCESS_TOKEN, service: true, NDCURVE_DEVELOPER_LICENSE_ACCESS_TOKEN };
+                SLYP_FEATURES_LIST[key].headers = { JWT: SERVICE_ACCESS_TOKEN, service: true, NDCURVE_DEVELOPER_LICENSE_ACCESS_TOKEN }; // TODO: CRITICAL: Security issue
         }
         res.json({ data: { ...SLYP_FEATURES_LIST, ...exp_features } });
     });
@@ -230,20 +280,21 @@ export const start = async (app, url, file) => {
     await registerFeatures(features);
     // Get unique kafka topics list from features
     let kafkaTopics = [];
-    for (let name in features) {
+    for (const name in features) {
         let feature = features[name];
-        if (feature.api.split(' ')[0].toLowerCase() === "get")
+        if (feature.api.split(' ')[0]?.toLowerCase() === "get")
             continue;
         kafkaTopics = [...new Set(kafkaTopics.concat([feature.topic]))];
     }
     // Subscribe to each topic
     for (let topic of kafkaTopics) {
-        Kafka.receive(`Features.${topic}`, async (topic, message) => {
+        const groupId = '';
+        Kafka.receive(`Features.${topic}`, groupId, async (topic, message) => {
             if (Utils.isEmpty(message.meta?.company))
                 message.meta = { ...message.meta, company: "GLOBAL", outlet: "GLOBAL" };
             if (!message?.feature)
                 return;
-            const timer = ms => new Promise(res => setTimeout(res, ms)); // A promise that resolves after "ms" Milliseconds
+            const timer = (ms) => new Promise(res => setTimeout(res, ms)); // A promise that resolves after "ms" Milliseconds
             topic = topic.replace(/^.*Features./, '');
             while (true) {
                 try {
@@ -251,7 +302,12 @@ export const start = async (app, url, file) => {
                     // // TODO: use $useChunks: [] once support is added in dip insert
                     // await Dip.insert(globalMeta, `users.txns`, { _id: `${message.user}_${iso_date}_${message.txn}`, user: message.user, feature: message.feature, date: message.date, created: message.date, updated: message.date, status: "Queued" }, {idempotent: true}) // Can always update the status later
                     // TODO: Avoid duplicate processing
-                    await features[message.feature].handler(topic, message);
+                    const feature = features[message.feature];
+                    if (!feature) {
+                        console.warn(`Feature ${message.feature} missing, in executing handler during Kafka.receive(topic: ${topic})`);
+                        throw new Error(`Feature ${message.feature} missing, in executing handler during Kafka.receive(topic: ${topic})`);
+                    }
+                    await feature.handler(topic, message);
                     await Dip.insert(globalMeta, "Features.txns", { _id: message.txn, status: "Processed" }, { idempotent: true });
                     break;
                 }
@@ -296,31 +352,13 @@ export const start = async (app, url, file) => {
         console.log('Messaging failed to start. Maybe missing redis');
     }
 };
-function prepareMessage(req) {
-    let txn = req.body.txn ?? Utils.uid();
-    let _id = req.body.data?._id ?? txn;
-    let { data, feature, app, user, outlet, company, client, version } = req.body;
-    let meta = req.meta;
-    let params = req.params;
-    return { data, params, meta, feature, app, user, outlet, company, client, version, txn, id: _id, date: new Date().getTime() };
-}
-const commandAction = async (req, res, topic) => {
-    let message = prepareMessage(req);
-    try {
-        await Kafka.send(`Features.${topic}`, message, message.user, { compression: Kafka.CompressionTypes.GZIP });
-    }
-    catch {
-        throw { status: 500, message: "Failed to queue the transaction" };
-    }
-    res.json({ data: { txn: message.txn, success: true, status: "Queued", featureQueued: true } });
-};
 let subscriptions = {
 // "coins.query.hello": "invoices.command.add",     // Consumer : Feature of Topic
 };
 let subscribed_consumers = {};
 async function subscribe() {
     let Features = { get, send };
-    for (let [key, { subscribe }] of Object.entries(features))
+    for (let [key, { subscribe }] of Object.entries(features)) {
         if (!Utils.isEmpty(subscribe) && subscriptions[key] !== subscribe && subscribed_consumers[key]) {
             try {
                 await subscribed_consumers[key].disconnect();
@@ -328,30 +366,37 @@ async function subscribe() {
             catch (_) { }
             delete subscribed_consumers[key];
         }
-    for (let key in SLYP_FEATURES_LIST)
-        if (!Utils.isEmpty(SLYP_FEATURES_LIST[key].subscribe) && subscriptions[key] !== SLYP_FEATURES_LIST[key].subscribe && subscribed_consumers[key]) {
+    }
+    for (let key in SLYP_FEATURES_LIST) {
+        const feature = SLYP_FEATURES_LIST[key];
+        if (!Utils.isEmpty(feature?.subscribe) && subscriptions[key] !== feature?.subscribe && subscribed_consumers[key]) {
             try {
                 await subscribed_consumers[key].disconnect();
             }
             catch (_) { }
             delete subscribed_consumers[key];
         }
-    for (let key in SLYP_FEATURES_LIST)
-        if (!Utils.isEmpty(SLYP_FEATURES_LIST[key].subscribe)) {
-            subscriptions[key] = SLYP_FEATURES_LIST[key].subscribe;
+    }
+    for (let key in SLYP_FEATURES_LIST) {
+        const feature = SLYP_FEATURES_LIST[key];
+        if (!Utils.isEmpty(feature?.subscribe)) {
+            subscriptions[key] = feature.subscribe;
         }
-    for (let [key, { subscribe }] of Object.entries(features))
+    }
+    for (let [key, { subscribe }] of Object.entries(features)) {
         if (!Utils.isEmpty(subscribe)) {
             subscriptions[key] = subscribe;
         }
+    }
     for (let consumer in subscriptions) {
         let publisher = subscriptions[consumer];
-        let { topic } = getFeature(publisher);
-        if (subscribed_consumers[consumer] || !getFeature(publisher))
+        const publisherFeature = getFeature(publisher);
+        if (subscribed_consumers[consumer] || !publisherFeature)
             continue;
-        let kafka_consumer = Kafka.receive(`Features.${topic}`, consumer, async (topic, message) => {
+        let { topic } = publisherFeature;
+        let kafka_consumer_promise = Kafka.receive(`Features.${topic}`, consumer, async (topic, message) => {
             topic = topic.replace(/^.*Features./, '');
-            const timer = ms => new Promise(res => setTimeout(res, ms)); // A promise that resolves after "ms" Milliseconds
+            const timer = (ms) => new Promise(res => setTimeout(res, ms)); // A promise that resolves after "ms" Milliseconds
             while (true) {
                 try {
                     await Features.send(message.meta, consumer, message.data, message.params);
@@ -363,6 +408,11 @@ async function subscribe() {
                 await timer(10000);
             }
         });
-        subscribed_consumers[consumer] = kafka_consumer;
+        kafka_consumer_promise
+            .then(kafka_consumer => {
+            subscribed_consumers[consumer] = kafka_consumer;
+        }).catch(err => {
+            throw new Error("Error: Remote service to service kafka Feature subscription.");
+        });
     }
 }

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) => {
@@ -31,8 +33,7 @@ export const createTopic = async (topic, partition, replicas) => {
 // ===========
 let consumers = [];
 const start_consumer = async function (topic, groupId, callback) {
-    callback = typeof groupId === "string" ? callback : groupId;
-    groupId = typeof groupId === "string" ? `${appName}.${groupId}` : `${appName}.${topic}`;
+    groupId = groupId ? `${appName}.${groupId}` : `${appName}.${topic}`;
     const consumer = kafka.consumer({ groupId: groupId });
     consumers.push(consumer);
     await consumer.connect();
@@ -46,7 +47,7 @@ const start_consumer = async function (topic, groupId, callback) {
                 success = await callback(topic, JSON.parse(message.value), partition);
             }
             catch (ex) {
-                success = await callback(topic, message.value, partition);
+                success = await callback(topic, message.value, partition); // NOTE: Beware: Ensure Kafka.receive<T> can handle raw message type that is not json parseable
             }
             await consumer.commitOffsets([{ topic, partition, offset: (Number(message.offset) + 1).toString() }]);
         },
@@ -79,7 +80,7 @@ const start_producer = async function (topic, message, key, options) {
 // start_producer('quickstart-events', 'Hello KafkaJS user! Little')
 export const receive = async function (topic, groupId, callback) {
     topic = topicPrefix + topic;
-    return (await start_consumer(topic, groupId, callback));
+    return await start_consumer(topic, groupId, callback);
 };
 export const send = async function (topic, message, key, options) {
     topic = topicPrefix + topic;

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
 }

package/libs/cpp.ts

@@ -1,8 +1,10 @@
 
 import crypto from 'node:crypto';
 
+type ValueRef = { value: bigint }
+type BytesRef = { value: number }
 
-function readContent(buffer: Uint8Array, valueRef, bytesRef) { // Buffer is assignable to Uint8Array so no need for Buffer | Uint8Array
+function readContent(buffer: Uint8Array, valueRef: ValueRef, bytesRef: BytesRef) { // Buffer is assignable to Uint8Array so no need for Buffer | Uint8Array
     const MASK = 0x7F;
     const MSB = 0x80;
     const MAX_VLQ_BYTES = 10;
@@ -21,7 +23,7 @@ function readContent(buffer: Uint8Array, valueRef, bytesRef) { // Buffer is assi
             return false;
         }
 
-        const byte = view[lenBytes];
+        const byte = view[lenBytes]!;
         lenBytes++;
 
         length |= BigInt(byte & MASK) << shift;
@@ -41,7 +43,7 @@ function readContent(buffer: Uint8Array, valueRef, bytesRef) { // Buffer is assi
 
 
 
-export function vlqToUint64(arrayBuffer) {
+export function vlqToUint64(arrayBuffer: Uint8Array) {
     // Objects act as containers to simulate C++ pointers/references
     const valueRef = { value: 0n };
     const bytesRef = { value: 0 };
@@ -63,7 +65,7 @@ export function vlqToUint64(arrayBuffer) {
 
 
 
-function writeVlqcontent(buffer, value) {
+function writeVlqcontent(buffer: Buffer, value: number | bigint) {
     const MASK = 0x7Fn;
     const MSB = 0x80;
     let bufferPtr = 0;
@@ -81,7 +83,7 @@ function writeVlqcontent(buffer, value) {
     return bufferPtr;
 }
 
-export function uint64ToVlq(value) {
+export function uint64ToVlq(value: number | bigint) {
     // 10 bytes is the maximum VLQ size for a uint64
     const out = Buffer.allocUnsafe(10);
     const size = writeVlqcontent(out, value);
@@ -93,7 +95,7 @@ export function uint64ToVlq(value) {
 
 
 
-export function sliceArrayBuffer(buffer, offset, length) {
+export function sliceArrayBuffer(buffer: Buffer | Uint8Array, offset: number, length: number) {
     // Ensure we are working with a Node.js Buffer
     const buf = Buffer.isBuffer(buffer) ? buffer : Buffer.from(buffer);
     const totalSize = buf.length;
@@ -113,13 +115,13 @@ export function sliceArrayBuffer(buffer, offset, 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) {
+export function stringToUtf8ArrayBuffer(arg: string) {
     // Converts the string into a Node.js Buffer encoded in UTF-8
     return Buffer.from(arg, 'utf8');
 }
 
 
-export function numberToSortableBytes(value) {
+export function numberToSortableBytes(value: number) {
     // 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);
@@ -148,7 +150,7 @@ export function numberToSortableBytes(value) {
 
 
 
-export function defaultHash(buffer) {
+export function defaultHash(buffer: Buffer | Uint8Array) {
     const buf = Buffer.isBuffer(buffer) ? buffer : Buffer.from(buffer);
 
     // Uses the high-speed, non-cryptographic xxhash64 algorithm
@@ -160,7 +162,7 @@ export function defaultHash(buffer) {
 }
 
 
-export function memcmpEqual(buffer1, buffer2) {
+export function memcmpEqual(buffer1: Buffer | Uint8Array, buffer2: Buffer | Uint8Array) {
     const b1 = Buffer.isBuffer(buffer1) ? buffer1 : Buffer.from(buffer1);
     const b2 = Buffer.isBuffer(buffer2) ? buffer2 : Buffer.from(buffer2);
 
@@ -168,7 +170,7 @@ export function memcmpEqual(buffer1, buffer2) {
 }
 
 
-export function arrayBufferToString(buffer) {
+export function arrayBufferToString(buffer: Buffer | Uint8Array) {
     const buf = Buffer.isBuffer(buffer) ? buffer : Buffer.from(buffer);
 
     // Decodes the buffer bytes as a UTF-8 JavaScript string
@@ -180,7 +182,7 @@ export function arrayBufferToString(buffer) {
 
 
 // Matches QString Response::getSliceAsText
-export function getSliceAsText(rawTextBuffer, offset: number, length: number): string {
+export function getSliceAsText(rawTextBuffer: Buffer, offset: number, length: number): string {
     // Reuses the identical slice boundary logic from above
     try {
     const slice = getSliceAsArrayBuffer(rawTextBuffer, offset, length);
@@ -191,7 +193,7 @@ export function getSliceAsText(rawTextBuffer, offset: number, length: number): s
 }
 
 // Matches QByteArray Response::getSliceAsArrayBuffer
-export function getSliceAsArrayBuffer(rawTextBuffer, offset: number, length: number): Buffer {
+export function getSliceAsArrayBuffer(rawTextBuffer: Buffer, offset: number, length: number): Buffer {
     const totalSize = rawTextBuffer.length;
 
     if (offset < 0 || offset >= totalSize) {

package/libs/dip/suffix/date.ts

@@ -1,4 +1,4 @@
-import {getNormalizedBounds, type Bounds} from './index.ts'
+import {getNormalizedBounds, type AbsoluteBounds} from './index.ts'
 import {addUTCYears, addUTCMonths, addUTCDays} from '../../utils.ts'
 
 
@@ -6,7 +6,7 @@ const MONTH_SHORT = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Se
 const MONTH_LONG = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"]
 
 
-export function formatDate(value, format) {
+export function formatDate(value: string | number | Date, format: string) {
 
     const dateObj = value instanceof Date ? value : new Date(value)
 
@@ -59,7 +59,7 @@ export function formatDate(value, format) {
         D: () => dates.join(separator),
     };
 
-    return format.replace(/YYYY|MMMM|MMM|YY|MM|DD|D/g, token => replacements[token]());
+    return format.replace(/YYYY|MMMM|MMM|YY|MM|DD|D/g, token => replacements[token as keyof typeof replacements]());
 }
 
 
@@ -83,7 +83,7 @@ export function formatDate(value, format) {
 
 
 
-export function fillDates(bounds_t, format) {
+export function fillDates(bounds_t: AbsoluteBounds, format: string) {
     const result = [];
 
     let step;
@@ -94,11 +94,11 @@ export function fillDates(bounds_t, format) {
     else
         step = "year";
 
-    let bounds: Bounds = { ...bounds_t, from: new Date(bounds_t.from), to: new Date(bounds_t.to) }
+    let bounds: AbsoluteBounds = { ...bounds_t, from: new Date(bounds_t.from), to: new Date(bounds_t.to) }
 
     bounds = getNormalizedBounds(bounds, "date")
 
-    while (bounds.from <= bounds.to) {
+    while (bounds.from! <= bounds.to!) {
         result.push(formatDate(bounds.from, format));
 
         switch (step) {