corebasic 1.0.206 → 1.0.208

package/libs/dip/suffix/query.js

@@ -0,0 +1,289 @@
+// Lightweight Query Matcher (JavaScript)
+// ========= Utility Functions =========
+
+function toF64(value) {
+    if (value === null || value === undefined) return 0;
+    if (typeof value === 'number') return value;
+    if (typeof value === 'string') {
+        const parsed = parseFloat(value);
+        return isNaN(parsed) ? 0 : parsed;
+    }
+    if (typeof value === 'boolean') return value ? 1 : 0;
+    return 0;
+}
+
+function getValueAt(obj, key) {
+    if (obj === null || obj === undefined) return null;
+    if (typeof obj !== 'object') return null;
+    return obj[key] !== undefined ? obj[key] : null;
+}
+
+// ========= Comparison Primitives =========
+
+function eqQuery(v1, v2) {
+    // Deep equality for objects/arrays, strict for primitives
+    if (v1 === v2) return true;
+    if (v1 === null || v2 === null) return v1 === v2;
+    if (typeof v1 !== typeof v2) {
+        // Try numeric comparison
+        if (typeof v1 === 'number' || typeof v2 === 'number') {
+            return toF64(v1) === toF64(v2);
+        }
+        return false;
+    }
+    if (typeof v1 === 'object') {
+        if (Array.isArray(v1) !== Array.isArray(v2)) return false;
+        if (Array.isArray(v1)) {
+            if (v1.length !== v2.length) return false;
+            for (let i = 0; i < v1.length; i++) {
+                if (!eqQuery(v1[i], v2[i])) return false;
+            }
+            return true;
+        }
+        const keys1 = Object.keys(v1);
+        const keys2 = Object.keys(v2);
+        if (keys1.length !== keys2.length) return false;
+        for (const key of keys1) {
+            if (!keys2.includes(key)) return false;
+            if (!eqQuery(v1[key], v2[key])) return false;
+        }
+        return true;
+    }
+    return false;
+}
+
+function gtQuery(v1, v2) {
+    return toF64(v1) > toF64(v2);
+}
+
+function gteQuery(v1, v2) {
+    return toF64(v1) >= toF64(v2);
+}
+
+function ltQuery(v1, v2) {
+    return toF64(v1) < toF64(v2);
+}
+
+function lteQuery(v1, v2) {
+    return toF64(v1) <= toF64(v2);
+}
+
+function existsQuery(v1, v2) {
+    const exists = v1 !== null && v1 !== undefined;
+    const condition = typeof v2 === 'boolean' ? v2 : true;
+    return condition === exists;
+}
+
+function beginQuery(input, arg) {
+    if (typeof input === 'string' && typeof arg === 'string') {
+        return input.startsWith(arg);
+    }
+    return false;
+}
+
+function endQuery(input, arg) {
+    if (typeof input === 'string' && typeof arg === 'string') {
+        return input.endsWith(arg);
+    }
+    return false;
+}
+
+function containsQuery(input, arg, caseSensitive = true) {
+    if (typeof input !== 'string') return false;
+
+    if (Array.isArray(arg)) {
+        if (arg.length === 0) return false;
+        let allMatch = true;
+        for (const v of arg) {
+            let needle = typeof v === 'string' ? v : String(v);
+            let haystack = input;
+            if (!caseSensitive) {
+                needle = needle.toLowerCase();
+                haystack = haystack.toLowerCase();
+            }
+            if (!haystack.includes(needle)) {
+                allMatch = false;
+                break;
+            }
+        }
+        return allMatch;
+    }
+
+    if (typeof arg === 'string') {
+        let needle = arg;
+        let haystack = input;
+        if (!caseSensitive) {
+            needle = needle.toLowerCase();
+            haystack = haystack.toLowerCase();
+        }
+        return haystack.includes(needle);
+    }
+
+    return false;
+}
+
+// ========= Query Commands =========
+
+function inQuery(input, args) {
+    if (Array.isArray(args)) {
+        for (const item of args) {
+            if (eqQuery(input, item)) return true;
+        }
+        return false;
+    }
+    if (args !== null && typeof args === 'object') return false;
+    return eqQuery(input, args);
+}
+
+function elemMatchQuery(input, query) {
+    if (!Array.isArray(input)) return false;
+
+    const term = query.$ || '$';
+    const captureLimit = query.$captureLimit || 0;
+    let countMatched = 0;
+
+    for (let index = 0; index < input.length; index++) {
+        if (andQuery(input[index], query)) {
+            if (captureLimit > 0 && countMatched >= captureLimit) break;
+            countMatched++;
+        }
+    }
+
+    return countMatched > 0;
+}
+
+function lengthQuery(input, arg) {
+    let len;
+    if (Array.isArray(input)) {
+        len = input.length;
+    } else if (typeof input === 'string') {
+        len = input.length;
+    } else {
+        return false;
+    }
+
+    if (arg !== null && typeof arg === 'object' && !Array.isArray(arg)) {
+        return andQuery(len, arg);
+    }
+    if (typeof arg === 'number') {
+        return len === arg;
+    }
+    return false;
+}
+
+function icaseQuery(input, arg) {
+    if (typeof input !== 'string') return false;
+
+    const lowerInput = input.toLowerCase();
+
+    if (arg !== null && typeof arg === 'object' && !Array.isArray(arg)) {
+        return andQuery(lowerInput, arg);
+    }
+    if (typeof arg === 'string') {
+        return eqQuery(lowerInput, arg.toLowerCase());
+    }
+    return false;
+}
+
+function selectCommand(key, input, value) {
+    switch (key) {
+        // Comparison
+        case '$':
+            return true;
+        case '$eq':
+            return eqQuery(input, value);
+        case '$ne':
+            return !eqQuery(input, value);
+        case '$gt':
+            return gtQuery(input, value);
+        case '$gte':
+            return gteQuery(input, value);
+        case '$lt':
+            return ltQuery(input, value);
+        case '$lte':
+            return lteQuery(input, value);
+        case '$in':
+            return inQuery(input, value);
+        case '$nin':
+            return !inQuery(input, value);
+
+        // Logical
+        case '$not':
+            return !andQuery(input, value);
+        case '$exists':
+            return existsQuery(input, value);
+        case '$or':
+            return orQuery(input, value);
+        case '$nor':
+            return !orQuery(input, value);
+        case '$and':
+            if (!Array.isArray(value)) return false;
+            for (const item of value) {
+                if (!andQuery(input, item)) return false;
+            }
+            return true;
+
+        // Array
+        case '$elemMatch':
+            return elemMatchQuery(input, value);
+        case '$length':
+            return lengthQuery(input, value);
+
+        // String matching
+        case '$icase':
+            return icaseQuery(input, value);
+        case '$begin':
+            return beginQuery(input, value);
+        case '$end':
+            return endQuery(input, value);
+        case '$contains':
+            return containsQuery(input, value);
+
+        default:
+            if (key.startsWith('$')) return true; // Unknown $keys pass through
+            return false;
+    }
+}
+
+function orQuery(input, value) {
+    if (!Array.isArray(value)) return false;
+    for (const item of value) {
+        if (andQuery(input, item)) return true;
+    }
+    return false;
+}
+
+function andQuery(input, qvalue) {
+    if (qvalue === null || qvalue === undefined) {
+        return eqQuery(input, qvalue);
+    }
+
+    if (typeof qvalue === 'object' && !Array.isArray(qvalue)) {
+        for (const [key, value] of Object.entries(qvalue)) {
+            if (key.startsWith('$')) {
+                if (!selectCommand(key, input, value)) {
+                    return false;
+                }
+            } else {
+                const v = (typeof value === 'object' && value !== null && !Array.isArray(value))
+                    ? andQuery(getValueAt(input, key), value)
+                    : eqQuery(getValueAt(input, key), value);
+                if (!v) return false;
+            }
+        }
+        return true;
+    }
+
+    if (Array.isArray(qvalue)) {
+        return false;
+    }
+
+    return eqQuery(input, qvalue);
+}
+
+// ========= Main Entry Point =========
+
+export function search(data, query) {
+    return andQuery(data, query);
+}
+

package/libs/dip/suffix/suffix.js

@@ -0,0 +1,109 @@
+import {entries, reduceRanges, extractBounds, getNormalizedBounds} from './index.js'
+import {formatDate, fillDates} from './date.js'
+
+
+
+const EXPLICIT_SUFFIX_POLICY_TYPES = new Set([  "string", "date", "number" ]);
+export async function suffix(doc, policies, insertMode, arg) {
+    let suffixes = [""]
+    for (const policy of policies) {
+
+        const value = typeof policy.value === "string" ? policy.value.trim() : undefined
+        if ("value" in policy && !value)
+            throw new Error(`Error: Invalid suffix policy fixed 'value' specified for key in Dip`)
+
+        let keys = value ? [value] : entries(policy.key, doc);
+        const [policy_type, format] = (policy.type  ?? "string").split(':')
+
+        if (!EXPLICIT_SUFFIX_POLICY_TYPES.has(policy_type))
+            throw new Error(`Error: Invalid suffix policy type specified for key ${policy.key} in Dip`)
+
+        if (policy_type === "string" && keys.filter(item => typeof item === "object").length)
+            throw new Error(`Error: Invalid numeric bounds on string type in suffix policy specified for key ${policy.key} in Dip`)
+
+        if (policy_type === "date") {
+            if (!format?.trim())
+                throw new Error(`Error: Invalid date format in suffix policy type specified for key ${policy.key} in Dip`)
+            if (format.includes('/'))
+                throw new Error(`Error: Invalid date format containing '/' in suffix policy type specified for key ${policy.key} in Dip`)
+        }
+
+        const ls_threshold = policy.ls_threshold ?? 5000
+
+        // ====== Range ======
+        let ranges = keys.filter(item =>  typeof item === "object")
+        keys = keys.filter(item =>  typeof item !== "object")
+
+        if (policy_type === "date") {
+            keys = keys.map(key => formatDate(key, format))
+            if (ranges.length) {
+                ranges = extractBounds(reduceRanges(ranges))
+                const from = ranges.from ?? policy.min // policy.min is always inclusive i.e $gte
+                const to = ranges.to ?? policy.max  // policy.max is always inclusive i.e $lte
+                const fromOp = ranges.from ? ranges.fromOp : "$gte" // policy.min is $gte
+                const toOp = ranges.to ? ranges.toOp : "$lte"  // policy.max is $lte
+                if (from === undefined || to === undefined) {
+                    keys = [] // Fall back to Dip.operation("ls").
+                    console.warn(`Warn: Missing suffix policy min/max bound for ${policy_type} range specified for key ${policy.key} in Dip`)
+                } else {
+                    ranges = fillDates({from, to, fromOp, toOp}, format)
+                    // console.log(ranges)
+                    if (ranges.length > ls_threshold) {
+                        keys = [] // Too many suffixes to enumerate. Fall back to Dip.operation("ls").
+                        console.warn(`Warn: Suffix ls_threshold exceeded for key ${policy.key} in Dip`)
+                    } else
+                        keys.push(...ranges)
+                }
+            }
+            keys = [...new Set(keys)];
+        } else if (policy_type === "number" && ranges.length) {
+            ranges = getNormalizedBounds(extractBounds(reduceRanges(ranges)), "number")
+            const from = ranges.from ?? policy.min // policy.min is always inclusive i.e $gte
+            const to = ranges.to ?? policy.max // policy.max is always inclusive i.e $lte
+            if (from === undefined || to === undefined) {
+                keys = [] // Fall back to Dip.operation("ls").
+                console.warn(`Warn: Missing suffix policy min/max bound for ${policy_type} range specified for key ${policy.key} in Dip`)
+            } else {
+                if (to - from + 1 > ls_threshold) {
+                    keys = [] // Too many suffixes to enumerate. Fall back to Dip.operation("ls").
+                    console.warn(`Warn: Suffix ls_threshold exceeded for key ${policy.key} in Dip`)
+                } else {
+                    for (let i = from; i <= to; i++)
+                        keys.push(i)
+                }
+                keys = [...new Set(keys)];
+            }
+        }
+        // =================
+
+        let ls = false
+        let suffixAssociatedKeys = {}
+
+        if (!keys.length && insertMode)
+            throw new Error(`Error: Missing suffix policy key ${policy.key} in Dip`)
+        if (!keys.length && !insertMode) {
+            ls = true
+            for (const suffix of suffixes) {
+                const dirs = (await Dip.operation("ls", { db: arg.db, collection: arg.collection, suffix })).filter(dir => !dir.startsWith('chunk-'))
+                suffixAssociatedKeys[suffix] = dirs
+            }
+            console.warn(`Warn: Query omitted suffix policy key ${policy.key} in Dip. Falling back to Dip.operation(ls), incurring additional performance and network round-trip overhead.`)
+        }
+        if (!ls && keys.some(key => typeof key !== "number" && typeof key !== "string")) // Dates are already string by this point
+            throw new Error(`Error: Invalid value for suffix policy key ${policy.key} in Dip`)
+
+        // =================
+
+        const next = [];
+        for (const suffix of suffixes) {
+            const currentKeys = ls ? suffixAssociatedKeys[suffix] : keys;
+            for (const key of currentKeys) {
+                next.push(`${suffix}/${key}`);
+            }
+        }
+        suffixes = next; // The "dead branches" disappear automatically because they never contribute any children.
+
+
+    }
+    return suffixes.length === 1 && suffixes[0] === "" ? [] : suffixes
+}