corebasic 1.0.230 → 1.0.232

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 ?? []