@based/db 0.0.1

package/dist/src/client/query/debug.js

@@ -0,0 +1,117 @@
+import picocolors from 'picocolors';
+import { isPropDef, REVERSE_TYPE_INDEX_MAP } from '../../server/schema/types.js';
+import { QueryDefType } from './types.js';
+export const debugQueryDef = (q, returnIt) => {
+    const loggableObject = { type: 'bla', schema: null };
+    const f = (a) => {
+        if (a === null) {
+            return null;
+        }
+        // if (a instanceof BasedNode) {
+        //   // will be changed
+        //   return 'basedNode'
+        // }
+        if (a instanceof Buffer) {
+            return new Uint8Array(a);
+        }
+        if (a instanceof Uint8Array) {
+            return a;
+        }
+        if (a instanceof Set) {
+            return a;
+        }
+        if (a instanceof Map) {
+            const b = new Map();
+            walk(a, b);
+            return b;
+        }
+        else if (typeof a === 'object') {
+            if (a.type && a.include && a.filter && a.range) {
+                return debugQueryDef(a, true);
+            }
+            if (isPropDef(a)) {
+                return `${a.path.join('.')}: ${a.prop} ${REVERSE_TYPE_INDEX_MAP[a.typeIndex]}`;
+            }
+            else {
+                const b = Array.isArray(a) ? [] : {};
+                walk(a, b);
+                return b;
+            }
+        }
+        return a;
+    };
+    const walk = (a, b) => {
+        if (a instanceof Map) {
+            a.forEach((v, k) => {
+                b.set(k, f(v));
+            });
+        }
+        else {
+            for (const key in a) {
+                if (key === 'schema') {
+                    b[key] = `Schema [${a.schema?.type}]`;
+                }
+                else {
+                    b[key] = f(a[key]);
+                }
+            }
+        }
+    };
+    walk(q, loggableObject);
+    loggableObject.type = QueryDefType[q.type];
+    if (!returnIt) {
+        console.dir(loggableObject, { depth: 10 });
+    }
+    return loggableObject;
+};
+export const debug = (x, start = 0, end = 0, label) => {
+    if (x === null || typeof x !== 'object') {
+        console.log(x);
+        return;
+    }
+    if (Array.isArray(x) && x[0] instanceof Buffer) {
+        debug(Buffer.concat(x), start, end, label);
+    }
+    else if (x instanceof Buffer) {
+        console.log(label || '');
+        if (!end) {
+            end = x.byteLength;
+        }
+        let len = Math.max(4, String(end - start).length + 1);
+        const w = Math.floor(process.stdout.columns / len) || 20;
+        const a = [...new Uint8Array(x.slice(start, end))];
+        for (let i = 0; i < Math.ceil((end - start) / w); i++) {
+            console.log(picocolors.gray(a
+                .slice(i * w, (i + 1) * w)
+                .map((v, j) => {
+                return String(j + i * w).padStart(len - 1, '0');
+            })
+                .join(' ')));
+            console.log(a
+                .slice(i * w, (i + 1) * w)
+                .map((v) => String(v).padStart(len - 1, '0'))
+                .map((v, j) => {
+                if (a[j + i * w] === 253) {
+                    return picocolors.magenta(v);
+                }
+                if (a[j + i * w] === 255) {
+                    return picocolors.blue(v);
+                }
+                if (a[j + i * w] === 254) {
+                    return picocolors.green(v);
+                }
+                if (a[j + i * w] === 252) {
+                    return picocolors.red(v);
+                }
+                return v;
+            })
+                .join(' '));
+        }
+        console.log('');
+        // -------------------------
+    }
+    else if ('type' in x && 'schema' in x && 'props' in x) {
+        debugQueryDef(x);
+    }
+};
+//# sourceMappingURL=debug.js.map

package/dist/src/client/query/display.d.ts

@@ -0,0 +1,5 @@
+import { QueryDef } from './types.js';
+import { BasedQueryResponse } from './BasedIterable.js';
+export declare const size: (size: number) => string;
+export declare const time: (time: number) => string;
+export declare const inspectData: (q: BasedQueryResponse, def: QueryDef, level: number, top: boolean, depth: number, hasId?: boolean) => string;

package/dist/src/client/query/display.js

@@ -0,0 +1,233 @@
+import picocolors from 'picocolors';
+import { BINARY, NUMBER, REFERENCE, REFERENCES, STRING, TIMESTAMP, } from '../../server/schema/types.js';
+const decimals = (v) => ~~(v * 100) / 100;
+const sizeCalc = (size) => {
+    if (size > 1e6) {
+        return `${decimals(size / 1e6)} mb`;
+    }
+    if (size > 1e3) {
+        return `${decimals(size / 1e3)} kb`;
+    }
+    return `${size} bytes`;
+};
+export const size = (size) => {
+    const str = sizeCalc(size);
+    if (size > 1e3 * 1e3 * 25) {
+        return picocolors.red(str);
+    }
+    else {
+        return picocolors.green(str);
+    }
+};
+const timeCalc = (time) => {
+    if (time > 1e3) {
+        return `${decimals(time / 1e3)} s`;
+    }
+    return `${decimals(time)} ms`;
+};
+export const time = (time) => {
+    const str = timeCalc(time);
+    if (time > 1e3) {
+        return picocolors.red(str);
+    }
+    else {
+        return picocolors.green(str);
+    }
+};
+const prettyPrintVal = (v, type) => {
+    if (type === BINARY) {
+        const nr = 12;
+        const isLarger = v.length > nr;
+        const x = [...v.slice(0, nr)].map((v) => {
+            return `${v}`.padStart(3, '0') + ' ';
+        });
+        return (picocolors.blue(x.join('')) +
+            (isLarger ? picocolors.dim('... ') : '') +
+            picocolors.italic(picocolors.dim(`${~~((Buffer.byteLength(v, 'utf8') / 1e3) * 100) / 100}kb`)));
+    }
+    if (type === STRING) {
+        if (v.length > 75) {
+            const chars = picocolors.italic(picocolors.dim(`${~~((Buffer.byteLength(v, 'utf8') / 1e3) * 100) / 100}kb`));
+            v =
+                v.slice(0, 75).replace(/\n/g, '\\n ') +
+                    picocolors.dim('...') +
+                    '" ' +
+                    chars;
+            return `"${v}`;
+        }
+        else {
+            return `"${v}"`;
+        }
+    }
+    if (type === TIMESTAMP) {
+        if (v === 0) {
+            return `0 ${picocolors.italic(picocolors.dim('No date'))}`;
+        }
+        else {
+            return `${v} ${picocolors.italic(picocolors.dim(new Date(v).toString().replace(/\(.+\)/, '')))}`;
+        }
+    }
+    return v;
+};
+const inspectObject = (object, q, path, level, isLast, isFirst, isObject, depth) => {
+    const prefix = ''.padEnd(level, ' ');
+    let str = '';
+    if (isFirst || isObject) {
+        str = '{\n';
+    }
+    else {
+        str = prefix + '{\n';
+    }
+    const prefixBody = ''.padEnd(level + 3, ' ');
+    let edges = [];
+    for (const k in object) {
+        const key = path ? path + '.' + k : k;
+        let def = q.props[key];
+        let v = object[k];
+        const isEdge = k[0] === '$';
+        if (k === '$searchScore') {
+            edges.push({ k, v, def: { typeIndex: NUMBER } });
+        }
+        else if (isEdge) {
+            if (q.edges?.props?.[k]) {
+                edges.push({ k, v, def: q.edges?.props?.[k] });
+            }
+        }
+        else {
+            str += prefixBody + `${k}: `;
+        }
+        if (isEdge) {
+            // skip
+        }
+        else if (key === 'id') {
+            // @ts-ignore
+            str += v + picocolors.italic(picocolors.dim(` ${q.target.type}`));
+            str += ',\n';
+        }
+        else if (!def) {
+            str += inspectObject(v, q, key, level + 2, false, false, true, depth) + '';
+        }
+        else if ('__isPropDef' in def) {
+            if (def.typeIndex === REFERENCES) {
+                str += inspectData(v, q.references.get(def.prop), level + 2, false, depth);
+            }
+            else if (def.typeIndex === REFERENCE) {
+                if (!v || !v.id) {
+                    str += 'null,\n';
+                }
+                else {
+                    str += inspectObject(v, q.references.get(def.prop), '', level + 2, false, false, true, depth);
+                }
+            }
+            else if (def.typeIndex === BINARY) {
+                if (v === undefined) {
+                    return '';
+                }
+                str += prettyPrintVal(v, def.typeIndex);
+            }
+            else if (def.typeIndex === STRING) {
+                if (v === undefined) {
+                    return '';
+                }
+                str += prettyPrintVal(v, def.typeIndex);
+            }
+            else if (def.typeIndex === TIMESTAMP) {
+                str += prettyPrintVal(v, def.typeIndex);
+            }
+            else {
+                if (typeof v === 'number') {
+                    str += picocolors.blue(v);
+                }
+                else {
+                    str += v;
+                }
+            }
+            if (def?.typeIndex !== REFERENCE) {
+                str += ',\n';
+            }
+        }
+        else {
+            str += ',\n';
+        }
+    }
+    for (const edge of edges) {
+        if (edge.def.typeIndex === REFERENCE) {
+            str += prefixBody + picocolors.bold(`${edge.k}: `);
+            str += inspectObject(edge.v, q.edges.references.get(edge.def.prop), '', level + 2, false, false, true, depth);
+        }
+        else if (edge.def.typeIndex === REFERENCES) {
+            str += prefixBody + picocolors.bold(`${edge.k}: `);
+            str +=
+                inspectData(edge.v, q.edges.references.get(edge.def.prop), level + 3, false, depth + 2) + '\n';
+        }
+        else {
+            str +=
+                prefixBody +
+                    picocolors.bold(`${edge.k}: `) +
+                    prettyPrintVal(edge.v, edge.def.typeIndex) +
+                    ',\n';
+        }
+    }
+    if (isObject) {
+        str += prefix + ' },\n';
+    }
+    else if (isLast) {
+        str += prefix + '}';
+    }
+    else {
+        str += prefix + '},\n';
+    }
+    return str;
+};
+export const inspectData = (q, def, level, top, depth, hasId = false) => {
+    const length = q.length;
+    const max = Math.min(length, depth);
+    const prefix = top ? '  ' : '';
+    let str;
+    let i = 0;
+    if (hasId) {
+        str = prefix;
+        level = level + 1;
+    }
+    else if (top) {
+        level = level + 3;
+        str = prefix + '[\n' + prefix + '  ';
+    }
+    else {
+        str = prefix + '[';
+    }
+    for (const x of q) {
+        str += inspectObject(x, def, '', level + 1, i === max - 1, i === 0, false, depth);
+        i++;
+        if (i >= max) {
+            break;
+        }
+    }
+    if (length > max) {
+        const morePrefix = ''.padStart(top ? 2 : level + 3, ' ');
+        str +=
+            ',\n' +
+                picocolors.dim(picocolors.italic(prefix +
+                    morePrefix +
+                    `...${length - max} More item${length - max !== 1 ? 's' : ''}\n`));
+        if (hasId) {
+            str += '';
+        }
+        else if (top) {
+            str += prefix + ']';
+        }
+        else {
+            str += prefix + ']'.padStart(level + 2, ' ');
+        }
+    }
+    else if (hasId) {
+    }
+    else if (top) {
+        str += '\n' + prefix + ']';
+    }
+    else {
+        str += ']';
+    }
+    return str;
+};
+//# sourceMappingURL=display.js.map

package/dist/src/client/query/filter/FilterBranch.d.ts

@@ -0,0 +1,13 @@
+import { DbClient } from '../../index.js';
+import { QueryDefFilter, QueryDef } from '../types.js';
+import { Operator } from './operators.js';
+import { FilterBranchFn } from './types.js';
+export declare class FilterBranch {
+    constructor(db: DbClient, filterBranch: QueryDefFilter, def: QueryDef);
+    db: DbClient;
+    filterBranch: QueryDefFilter;
+    def: QueryDef;
+    or(fn: FilterBranchFn): FilterBranch;
+    or(field: string, operator?: Operator | boolean, value?: any): FilterBranch;
+    filter(field: string, operator?: Operator | boolean, value?: any): this;
+}

package/dist/src/client/query/filter/FilterBranch.js

@@ -0,0 +1,29 @@
+import { convertFilter, filter, filterOr } from './filter.js';
+export class FilterBranch {
+    constructor(db, filterBranch, def) {
+        this.def = def;
+        this.filterBranch = filterBranch;
+        this.db = db;
+    }
+    db;
+    filterBranch;
+    def;
+    or(field, operator, value) {
+        if (typeof field === 'function') {
+            const f = new FilterBranch(this.db, filterOr(this.db, this.def, [], this.filterBranch), this.def);
+            field(f);
+            this.def.filter.size += f.filterBranch.size;
+        }
+        else {
+            const f = convertFilter(field, operator, value);
+            filterOr(this.db, this.def, f, this.filterBranch);
+        }
+        return this;
+    }
+    filter(field, operator, value) {
+        const f = convertFilter(field, operator, value);
+        filter(this.db, this.def, f, this.filterBranch);
+        return this;
+    }
+}
+//# sourceMappingURL=FilterBranch.js.map

package/dist/src/client/query/filter/createFixedFilterBuffer.d.ts

@@ -0,0 +1,3 @@
+import { PropDef, PropDefEdge } from '../../../server/schema/types.js';
+export declare const writeFixed: (prop: PropDef | PropDefEdge, buf: Buffer, value: any, size: number, offset: number, op: number) => void;
+export declare const createFixedFilterBuffer: (prop: PropDef | PropDefEdge, size: number, op: number, value: any, sort: boolean) => Buffer;

package/dist/src/client/query/filter/createFixedFilterBuffer.js

@@ -0,0 +1,101 @@
+import { BINARY, STRING, REFERENCES, } from '../../../server/schema/types.js';
+import { propIsSigned } from '../../../server/schema/utils.js';
+import { negateType, stripNegation } from './operators.js';
+import { parseFilterValue } from './parseFilterValue.js';
+// -------------------------------------------
+// conditions normal
+// field, [size 2]
+// [or = 0] [size 2] [start 2], [op], value[size]
+// -------------------------------------------
+// conditions or fixed
+// field, [size 2]
+// [or = 1] [size 2] [start 2] [op], [repeat 2], value[size] value[size] value[size]
+// -------------------------------------------
+// conditions or variable
+// field, [size 2]
+// [or = 2] [size 2] [start 2], [op], [size 2], value[size], [size 2], value[size]
+// -------------------------------------------
+export const writeFixed = (prop, buf, value, size, offset, op) => {
+    if (prop.typeIndex === BINARY || prop.typeIndex === STRING) {
+        if (typeof value === 'string') {
+            const size = buf.write(value, offset + 1, 'utf8');
+            buf[offset] = size;
+        }
+        else if (value instanceof Buffer) {
+            buf.set(value, offset);
+        }
+        else {
+            throw new Error('Incorrect filter value for ' + prop.path);
+        }
+    }
+    else if (size === 1) {
+        buf[offset] = value;
+    }
+    else {
+        if (size === 8) {
+            buf.writeDoubleLE(value, offset);
+        }
+        else if (propIsSigned(prop)) {
+            if (size === 4) {
+                buf.writeInt32LE(value, offset);
+            }
+            else if (size === 2) {
+                buf.writeInt16LE(value, offset);
+            }
+            else if (size === 1) {
+                buf[offset] = value;
+            }
+        }
+        else if (size === 4) {
+            buf.writeUInt32LE(value, offset);
+        }
+        else if (size === 2) {
+            buf.writeUInt16LE(value, offset);
+        }
+    }
+};
+// Modes
+// default = 0,
+// orFixed = 1,
+// orVar = 2,
+export const createFixedFilterBuffer = (prop, size, op, value, sort) => {
+    let buf;
+    const start = prop.start;
+    if (Array.isArray(value)) {
+        // [or = 1] [size 2] [start 2] [op], [repeat 2], value[size] value[size] value[size]
+        const len = value.length;
+        buf = Buffer.allocUnsafe(10 + len * size);
+        buf[0] = negateType(op);
+        buf[1] = prop.typeIndex === REFERENCES && op === 1 ? 3 : 1;
+        buf.writeUInt16LE(size, 2);
+        buf.writeUInt16LE(start, 4);
+        buf[6] = stripNegation(op);
+        buf[7] = prop.typeIndex;
+        buf.writeUInt16LE(len, 8);
+        if (sort) {
+            value = new Uint32Array(value.map((v) => parseFilterValue(prop, v)));
+            value.sort();
+            for (let i = 0; i < len; i++) {
+                buf.writeUInt32LE(value[i], 10 + i * size);
+            }
+        }
+        else {
+            for (let i = 0; i < len; i++) {
+                writeFixed(prop, buf, parseFilterValue(prop, value[i]), size, 10 + i * size, op);
+            }
+        }
+    }
+    else {
+        // [or = 0] [size 2] [start 2], [op], value[size]
+        buf = Buffer.allocUnsafe(8 + size);
+        buf[0] = negateType(op);
+        buf[1] = 0;
+        buf.writeUInt16LE(size, 2);
+        buf.writeUInt16LE(start, 4);
+        buf[6] = stripNegation(op);
+        buf[7] = prop.typeIndex;
+        writeFixed(prop, buf, parseFilterValue(prop, value), size, 8, op);
+    }
+    return buf;
+};
+//# sourceMappingURL=createFixedFilterBuffer.js.map

package/dist/src/client/query/filter/createReferenceFilter.d.ts

@@ -0,0 +1,2 @@
+import { PropDef, PropDefEdge } from '../../../server/schema/types.js';
+export declare const createReferenceFilter: (prop: PropDef | PropDefEdge, op: number, value: any) => Buffer;

package/dist/src/client/query/filter/createReferenceFilter.js

@@ -0,0 +1,24 @@
+import { negateType, stripNegation } from './operators.js';
+export const createReferenceFilter = (prop, op, value) => {
+    let buf;
+    const len = Array.isArray(value) ? value.length : 1;
+    buf = Buffer.allocUnsafe(11 + len * 8);
+    buf[0] = negateType(op);
+    buf[1] = 5;
+    buf.writeUInt16LE(8, 2);
+    buf.writeUInt16LE(len, 4);
+    buf[6] = stripNegation(op);
+    buf[7] = prop.typeIndex;
+    buf[8] = 0;
+    buf.writeUInt16LE(prop.inverseTypeId, 9);
+    if (Array.isArray(value)) {
+        for (let i = 0; i < len; i++) {
+            buf.writeUInt32LE(value[i], 11 + i * 8);
+        }
+    }
+    else {
+        buf.writeUInt32LE(value, 11);
+    }
+    return buf;
+};
+//# sourceMappingURL=createReferenceFilter.js.map

package/dist/src/client/query/filter/createVariableFilterBuffer.d.ts

@@ -0,0 +1,2 @@
+import { PropDef, PropDefEdge } from '../../../server/schema/types.js';
+export declare const createVariableFilterBuffer: (value: any, prop: PropDef | PropDefEdge, op: number) => Buffer;

package/dist/src/client/query/filter/createVariableFilterBuffer.js

@@ -0,0 +1,81 @@
+import { ALIAS } from '../../../server/schema/types.js';
+import { negateType, stripNegation } from './operators.js';
+import { createFixedFilterBuffer } from './createFixedFilterBuffer.js';
+const parseValue = (value, prop, op) => {
+    let val = value;
+    if (op === 19 && typeof val === 'string') {
+        val = val.toLowerCase();
+    }
+    if (val instanceof Uint8Array ||
+        typeof value === 'string' ||
+        !prop.separate ||
+        op !== 1) {
+        val = Buffer.from(val);
+    }
+    if (!(val instanceof Buffer)) {
+        throw new Error('Incorrect value for filter ' + prop.path);
+    }
+    return val;
+};
+export const createVariableFilterBuffer = (value, prop, op) => {
+    let isOr = 4;
+    let val;
+    let buf;
+    if (Array.isArray(value)) {
+        if (op !== 1 || !prop.separate) {
+            isOr = 2;
+            const x = [];
+            for (const v of value) {
+                const a = parseValue(v, prop, op);
+                const size = Buffer.allocUnsafe(2);
+                size.writeUint16LE(a.byteLength);
+                x.push(size, a);
+            }
+            val = Buffer.concat(x);
+        }
+        else {
+            const x = [];
+            for (const v of value) {
+                x.push(parseValue(v, prop, op));
+            }
+            val = x;
+        }
+    }
+    else {
+        val = parseValue(value, prop, op);
+    }
+    // --------------------
+    if (op === 3 || op === 1 || op === 2 || op === 16 || op === 18 || op === 19) {
+        if (prop.separate) {
+            if (op === 1 && prop.typeIndex !== ALIAS) {
+                // 17 crc32 check
+                buf = createFixedFilterBuffer(prop, 8, 17, val, false);
+            }
+            else {
+                buf = writeVarFilter(isOr, val, buf, op, prop, 0, 0);
+            }
+        }
+        else {
+            // HANDLE EQUAL
+            buf = writeVarFilter(isOr, val, buf, op, prop, prop.start, prop.len);
+        }
+    }
+    else {
+        console.log('OP NOT SUPPORTED YET =>', op);
+    }
+    return buf;
+};
+function writeVarFilter(isOr, val, buf, op, prop, start, len) {
+    const size = val.byteLength;
+    buf = Buffer.allocUnsafe(12 + size);
+    buf[0] = negateType(op);
+    buf[1] = isOr;
+    buf.writeUInt16LE(start, 2);
+    buf.writeUint16LE(len, 4);
+    buf.writeUint32LE(size, 6);
+    buf[10] = stripNegation(op);
+    buf[11] = prop.typeIndex;
+    buf.set(val, 12);
+    return buf;
+}
+//# sourceMappingURL=createVariableFilterBuffer.js.map

package/dist/src/client/query/filter/filter.d.ts

@@ -0,0 +1,10 @@
+import { QueryDef, QueryDefFilter } from '../types.js';
+import { SchemaTypeDef } from '../../../server/schema/schema.js';
+import { Operator } from './operators.js';
+import { Filter, FilterAst } from './types.js';
+import { DbClient } from '../../index.js';
+export { Operator, Filter };
+export declare const filterRaw: (db: DbClient, filter: Filter, schema: SchemaTypeDef, conditions: QueryDefFilter, def: QueryDef) => number;
+export declare const filter: (db: DbClient, def: QueryDef, filterAst: FilterAst, conditions: QueryDefFilter) => void;
+export declare const filterOr: (db: DbClient, def: QueryDef, filterAst: FilterAst[], conditions: QueryDefFilter) => QueryDefFilter;
+export declare const convertFilter: (field: string, operator?: Operator | boolean, value?: any) => FilterAst;