corebasic 1.0.229 → 1.0.231

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) {

package/libs/dip/suffix/index.ts

@@ -1,18 +1,35 @@
 
+export type BoundValue = number | string | Date
+export type BoundFromOp = "$gt" | "$gte"
+export type BoundToOp = "$lt" | "$lte"
 
+export type Bounds = {
+    values: unknown[],
+    from: BoundValue | unknown;
+    to: BoundValue | unknown;
+    fromOp: BoundFromOp | unknown;
+    toOp: BoundToOp | unknown;
+}
+export type AbsoluteBounds = {
+    from: BoundValue;
+    to: BoundValue;
+    fromOp: BoundFromOp;
+    toOp: BoundToOp;
+}
 
-function flatten_id_values(target_key, values) {
-    let flattened = [];
+
+function flatten_id_values(target_key: string, values: unknown): unknown[] {
+    let flattened: unknown[] = [];
     flatten_value(target_key, values, flattened, false);
     return flattened
 }
 
-function flatten_value(target_key, value, flattened, ancestor_has_id) {
+function flatten_value(target_key: string, value: unknown, flattened: unknown[], ancestor_has_id: boolean) {
     const is_array = Array.isArray(value)
     const is_object = value !== null && !is_array && typeof value === "object";
     const is_regular = typeof value === "boolean" || typeof value === "number" || typeof value === "string"
-    const map = value
-    const arr = value
+    const map = value as Record<string, unknown>
+    const arr = value as unknown[]
 
     if (is_regular) {
         flattened.push(value);
@@ -72,7 +89,7 @@ function flatten_value(target_key, value, flattened, ancestor_has_id) {
 }
 
 
-export function entries(target_key: string, query, binary_slice?: Buffer) {
+export function entries(target_key: string, query: unknown, binary_slice?: Buffer): unknown[] {
     let result  = flatten_id_values(target_key, query); // extract all valid _id
 
     // let cows = result.map(v => extract_direct_id(v, binary_slice))
@@ -95,19 +112,21 @@ export function entries(target_key: string, query, binary_slice?: Buffer) {
 // reduceRanges() intentionally computes a conservative (wider) approximation.
 // It is used only for suffix policy planning, where false positives are acceptable
 // (extra suffix scans) but false negatives are not.
-export function reduceRanges(values) {
+export function reduceRanges(values: unknown[]) {
     let gt = null;
     let gte = null;
     let lt = null;
     let lte = null;
     const other = [];
 
-    for (const value of values) {
-        if (typeof value !== "object" || value === null || Array.isArray(value)) {
-            other.push(value);
+    for (const v of values) {
+        if (typeof v !== "object" || v === null || Array.isArray(v)) {
+            other.push(v);
             continue;
         }
 
+        const value = v as Record<string, {$gt?: BoundValue, $gte?: BoundValue, $lt?: BoundValue, $lte?: BoundValue}>
+
         if ("$gt" in value) {
             if (gt === null || value.$gt < gt)
                 gt = value.$gt;
@@ -160,31 +179,27 @@ export function reduceRanges(values) {
     return other;
 }
 
-export type Bounds = {
-    values: any[],
-    from: number | string | Date;
-    to: number | string | Date;
-    fromOp: "$gt" | "$gte";
-    toOp: "$lt" | "$lte";
-}
+
 
 // reduceRanges() resolves conflicting bounds before extractBounds() runs.
 // extractBounds() receives at most one lower bound and atmost one upper bound. reduceRanges() ensures this
 // The for loop in extractBounds() may look slightly misleading because it looks like it is designed to resolve conflicts: but reduceRanges() has already done the conflict resolution.
 // NOTE CRITICAL: extractBounds() MUST ONLY BE RUN ON THE OUTPUT OF reduceRanges()
-export function extractBounds(values): Bounds {
-    let lower = null;
-    let upper = null;
-    let lowerOp = null
-    let upperOp = null
+export function extractBounds(values: unknown[]): Bounds {
+    let lower: BoundValue | unknown = null;
+    let upper: BoundValue | unknown = null;
+    let lowerOp: BoundFromOp | unknown = null
+    let upperOp: BoundToOp | unknown = null
     const remaining = [];
 
-    for (const value of values) {
-        if (typeof value !== "object" || value === null || Array.isArray(value)) {
-            remaining.push(value);
+    for (const v of values) {
+        if (typeof v !== "object" || v === null || Array.isArray(v)) {
+            remaining.push(v);
             continue;
         }
 
+        const value = v as Record<string, {$gt?: BoundValue, $gte?: BoundValue, $lt?: BoundValue, $lte?: BoundValue}>
+
         if ("$gt" in value) {
             lower = value.$gt;
             lowerOp = "$gt"
@@ -212,7 +227,7 @@ export function extractBounds(values): Bounds {
 }
 
 // Converts exclusive bounds ($gt/$lt) into inclusive bounds
-export function getNormalizedBounds(bounds_t: Bounds, type): Bounds {
+export function getNormalizedBounds<T extends Bounds | AbsoluteBounds>(bounds_t: T, type: "number" | "date"): T {
     let bounds = {...bounds_t}
 
     if (type === "number") {

package/libs/dip/suffix/policy.ts

@@ -1,10 +1,11 @@
-import {entries, reduceRanges, extractBounds} from './index.ts'
+import {entries, reduceRanges, extractBounds, type Bounds, type BoundValue} from './index.ts'
 import {suffix} from './suffix.ts'
 
 
 
 
-export function overlaps(a, b) {
+export function overlaps(a: Bounds, b: Bounds) {
+
     const aFrom = a.from ?? -Infinity;
     const aTo   = a.to   ??  Infinity;
 
@@ -12,9 +13,11 @@ export function overlaps(a, b) {
     const bTo   = b.to   ??  Infinity;
 
 
+    const max = (a: BoundValue, b: BoundValue) => a > b ? a : b
+    const min = (a: BoundValue, b: BoundValue) => a < b ? a : b
 
-    const left = Math.max(aFrom, bFrom);
-    const right = Math.min(aTo, bTo);
+    const left = max(aFrom as BoundValue, bFrom as BoundValue);
+    const right = min(aTo as BoundValue, bTo as BoundValue);
 
     if (left < right)
         return true;
@@ -35,7 +38,7 @@ export function overlaps(a, b) {
 
 
 
-export function contains(bounds, value) {
+export function contains(bounds: Bounds, value: BoundValue) {
     const from = bounds.from ?? -Infinity;
     const to   = bounds.to   ??  Infinity;
 
@@ -56,7 +59,7 @@ export function contains(bounds, value) {
     // return value >= from && value <= to;
 }
 
-export function intersects(w_values, w_bounds, q_values, q_bounds) {
+export function intersects(w_values: BoundValue[], w_bounds: Bounds | null, q_values: BoundValue[], q_bounds: Bounds | null) {
     // value ↔ value
     for (const value of w_values) {
         if (q_values.includes(value))
@@ -88,7 +91,7 @@ export function intersects(w_values, w_bounds, q_values, q_bounds) {
 
 
 // NOTE: Matching is based on intersection, not equality. A policy matches if, for every key in `when`, there exists at least one value that satisfies both the `when` constraint and the query constraint.
-export function matchPolicy(query, when, g_obj?: Record<string, any>) {
+export function matchPolicy(query: Record<string, any>, when: Record<string, any>, g_obj?: Record<string, unknown[]>) {
     let obj = g_obj ?? {}
     for (let key in when) {
         if (key === "$and" || key === "$or") {
@@ -124,7 +127,7 @@ export function matchPolicy(query, when, g_obj?: Record<string, any>) {
         q_values = q_values.filter(item =>  typeof item !== "object")
         const q_bounds = q_ranges.length ? extractBounds(reduceRanges(q_ranges)) : null
 
-        if (!intersects(w_values, w_bounds, q_values, q_bounds))
+        if (!intersects(w_values as BoundValue[], w_bounds, q_values as BoundValue[], q_bounds))
             return false;
 
     }
@@ -132,14 +135,14 @@ export function matchPolicy(query, when, g_obj?: Record<string, any>) {
 }
 
 
+type SuffixItem = { key?: string; value?: string; type: string; ls_threshold?: number; min?: number; max?: number }
 
-
-
+type CollectionsJsonType = Record<string, {policy?: {when: object, suffix: SuffixItem[]}[]}>
 type Arg = { db: string; collection: string[]; }
 
-export async function applySuffixPolicy(COLLECTIONS_JSON, collections, query, insertMode?: boolean, arg?: Arg) {
-    collections = Array.isArray(collections) ? collections : [collections]
-    let suffixes = []
+export async function applySuffixPolicy(COLLECTIONS_JSON: CollectionsJsonType, cols: string | string[], query: Record<string, any>, insertMode?: boolean, arg?: Arg) {
+    const collections = Array.isArray(cols) ? cols : [cols]
+    let suffixes: string[] = []
 
     for (let collection of collections) {
         const collection_policy = COLLECTIONS_JSON[collection]?.policy ?? []