@based/db 0.0.1

package/dist/src/client/query/include/utils.js

@@ -0,0 +1,41 @@
+import { REFERENCE, } from '../../../server/schema/types.js';
+import { createQueryDef } from '../queryDef.js';
+import { QueryDefType } from '../types.js';
+export const getAllFieldFromObject = (tree, arr = []) => {
+    for (const key in tree) {
+        const leaf = tree[key];
+        if (!leaf.typeIndex && !leaf.__isPropDef) {
+            getAllFieldFromObject(leaf, arr);
+        }
+        else {
+            arr.push(leaf.path.join('.'));
+        }
+    }
+    return arr;
+};
+const createRefQueryDef = (db, def, t) => {
+    const defRef = createQueryDef(db, t.typeIndex === REFERENCE
+        ? QueryDefType.Reference
+        : QueryDefType.References, {
+        type: t.inverseTypeName,
+        propDef: t,
+    });
+    def.references.set(t.prop, defRef);
+    return defRef;
+};
+export const createOrGetRefQueryDef = (db, def, t) => {
+    if (!def.references.has(t.prop)) {
+        return createRefQueryDef(db, def, t);
+    }
+    return def.references.get(t.prop);
+};
+export const createOrGetEdgeRefQueryDef = (db, def, t) => {
+    def.edges ??= createQueryDef(db, QueryDefType.Edge, {
+        ref: t,
+    });
+    def.edges.props ??= {};
+    def.edges.props[t.name] = t;
+    const refDef = createOrGetRefQueryDef(db, def.edges, t);
+    return refDef;
+};
+//# sourceMappingURL=utils.js.map

package/dist/src/client/query/include/walk.d.ts

@@ -0,0 +1,3 @@
+import { QueryDef } from '../types.js';
+import { DbClient } from '../../index.js';
+export declare const walkDefs: (db: DbClient, def: QueryDef, f: string) => void;

package/dist/src/client/query/include/walk.js

@@ -0,0 +1,70 @@
+import { isPropDef, REFERENCE, REFERENCES, } from '../../../server/schema/types.js';
+import { createQueryDef } from '../queryDef.js';
+import { isRefDef, QueryDefType } from '../types.js';
+import { getAllFieldFromObject, createOrGetRefQueryDef } from './utils.js';
+import { includeFields, includeProp, includeAllProps } from './props.js';
+export const walkDefs = (db, def, f) => {
+    const prop = def.props[f];
+    const path = f.split('.');
+    if (!prop) {
+        let t = def.schema.tree;
+        for (let i = 0; i < path.length; i++) {
+            const p = path[i];
+            if (isRefDef(def) && p[0] == '$') {
+                if (!def.edges) {
+                    def.edges = createQueryDef(db, QueryDefType.Edge, {
+                        ref: def.target.propDef,
+                    });
+                }
+                const edgeProp = def.edges.props[p];
+                if (edgeProp.typeIndex === REFERENCE ||
+                    edgeProp.typeIndex === REFERENCES) {
+                    const refDef = createOrGetRefQueryDef(db, def.edges, edgeProp);
+                    if (path.length - 1 === i) {
+                        includeAllProps(refDef);
+                    }
+                    else {
+                        const f = path.slice(i + 1).join('.');
+                        if (!includeProp(refDef, refDef.props[f])) {
+                            includeFields(refDef, [f]);
+                        }
+                        return;
+                    }
+                }
+                else {
+                    def.edges.include.props.add(edgeProp.prop);
+                }
+                return;
+            }
+            t = t[p];
+            if (!t) {
+                return;
+            }
+            if (isPropDef(t) &&
+                (t.typeIndex === REFERENCE || t.typeIndex === REFERENCES)) {
+                const refDef = createOrGetRefQueryDef(db, def, t);
+                const f = path.slice(i + 1).join('.');
+                if (!includeProp(refDef, refDef.props[f])) {
+                    includeFields(refDef, [f]);
+                }
+                return;
+            }
+        }
+        const tree = def.schema.tree[path[0]];
+        if (tree) {
+            const endFields = getAllFieldFromObject(tree);
+            for (const field of endFields) {
+                walkDefs(db, def, field);
+            }
+        }
+    }
+    else if (prop.typeIndex === REFERENCE || prop.typeIndex === REFERENCES) {
+        const refDef = createOrGetRefQueryDef(db, def, prop);
+        includeAllProps(refDef);
+        return;
+    }
+    else {
+        includeProp(def, prop);
+    }
+};
+//# sourceMappingURL=walk.js.map

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

@@ -0,0 +1,10 @@
+export * from './queryDef.js';
+export * from './types.js';
+export * from './include/props.js';
+export * from './include/toBuffer.js';
+export * from './toBuffer.js';
+export * from './filter/filter.js';
+export * from './filter/toBuffer.js';
+export * from './sort.js';
+export * from './debug.js';
+export * from './read/read.js';

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

@@ -0,0 +1,11 @@
+export * from './queryDef.js';
+export * from './types.js';
+export * from './include/props.js';
+export * from './include/toBuffer.js';
+export * from './toBuffer.js';
+export * from './filter/filter.js';
+export * from './filter/toBuffer.js';
+export * from './sort.js';
+export * from './debug.js';
+export * from './read/read.js';
+//# sourceMappingURL=query.js.map

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

@@ -0,0 +1,3 @@
+import { DbClient } from '../index.js';
+import { QueryDef, QueryDefType, QueryTarget } from './types.js';
+export declare const createQueryDef: (db: DbClient, type: QueryDefType, target: QueryTarget) => QueryDef;

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

@@ -0,0 +1,54 @@
+import { MAX_RANGE_PROP_LIMIT, MAX_RANGE_REF_LIMIT } from './thresholds.js';
+import { QueryDefType, } from './types.js';
+const createEmptySharedDef = () => {
+    const q = {
+        filter: { conditions: new Map(), size: 0 },
+        range: { offset: 0, limit: 0 },
+        include: {
+            stringFields: new Set(),
+            props: new Set(),
+            propsRead: {},
+            main: {
+                len: 0,
+                include: {},
+            },
+        },
+        sort: null,
+        references: new Map(),
+    };
+    return q;
+};
+export const createQueryDef = (db, type, target) => {
+    const queryDef = createEmptySharedDef();
+    if (type === QueryDefType.Edge) {
+        const t = target;
+        const q = queryDef;
+        q.props = t.ref.edges;
+        q.reverseProps = t.ref.reverseEdges;
+        q.type = type;
+        q.target = t;
+        return q;
+    }
+    else {
+        const t = target;
+        const q = queryDef;
+        q.schema = db.schemaTypesParsed[t.type];
+        q.props = q.schema.props;
+        q.type = type;
+        q.target = t;
+        if (type === QueryDefType.Root) {
+            // IDS sort
+            if (t.ids) {
+                q.range.limit = t.ids.length; // 1k?
+            }
+            else {
+                q.range.limit = MAX_RANGE_PROP_LIMIT;
+            }
+        }
+        else if (type === QueryDefType.References) {
+            q.range.limit = MAX_RANGE_REF_LIMIT;
+        }
+        return q;
+    }
+};
+//# sourceMappingURL=queryDef.js.map

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

@@ -0,0 +1,8 @@
+import { QueryDef } from '../types.js';
+export type Item = {
+    id: number;
+} & {
+    [key: string]: any;
+};
+export declare const readAllFields: (q: QueryDef, result: Buffer, offset: number, end: number, item: Item, id: number) => number;
+export declare const resultToObject: (q: QueryDef, result: Buffer, end: number, offset?: number) => any;

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

@@ -0,0 +1,303 @@
+import { ALIAS, ALIASES, BINARY, BOOLEAN, ENUM, INT16, INT32, INT8, NUMBER, STRING, TEXT, TIMESTAMP, UINT16, UINT32, UINT8, } from '../../../server/schema/types.js';
+import { read } from '../../string.js';
+const addField = (p, value, item, defaultOnly = false) => {
+    let i = p.__isEdge === true ? 1 : 0;
+    const len = p.path.length;
+    if (len - i === 1) {
+        const field = p.path[i];
+        if (!defaultOnly || !(field in item)) {
+            item[field] = value;
+        }
+    }
+    else {
+        let select = item;
+        for (; i < len; i++) {
+            const field = p.path[i];
+            if (i === len - 1) {
+                if (!defaultOnly || !(field in select)) {
+                    select[field] = value;
+                }
+            }
+            else {
+                select = select[field] ?? (select[field] = {});
+            }
+        }
+    }
+};
+const readMainValue = (prop, result, index, item) => {
+    // 1: timestamp, 4: number
+    if (prop.typeIndex === TIMESTAMP || prop.typeIndex === NUMBER) {
+        addField(prop, result.readDoubleLE(index), item);
+    }
+    // 5: uint32
+    else if (prop.typeIndex === UINT32) {
+        addField(prop, result.readUInt32LE(index), item);
+    }
+    // 9: boolean
+    else if (prop.typeIndex === BOOLEAN) {
+        addField(prop, Boolean(result[index]), item);
+    }
+    // 10: Enum
+    else if (prop.typeIndex === ENUM) {
+        if (result[index] === 0) {
+            addField(prop, undefined, item);
+        }
+        else {
+            addField(prop, prop.enum[result[index] - 1], item);
+        }
+    }
+    // 11: string
+    else if (prop.typeIndex === STRING) {
+        // Also remove this default then (same as other string)
+        const len = result[index];
+        if (len !== 0) {
+            const str = result.toString('utf-8', index + 1, index + len + 1);
+            addField(prop, str, item);
+        }
+        else {
+            addField(prop, '', item);
+        }
+    }
+    // 11: string
+    else if (prop.typeIndex === BINARY) {
+        addField(prop, new Uint8Array(result.buffer, index + 1, result[index]), item);
+    }
+    // 18: int8
+    else if (prop.typeIndex === INT8) {
+        addField(prop, result.readInt8(index), item);
+    }
+    // 19: uint8
+    else if (prop.typeIndex === UINT8) {
+        addField(prop, result.readUint8(index), item);
+    }
+    // 20: int16
+    else if (prop.typeIndex === INT16) {
+        addField(prop, result.readInt16LE(index), item);
+    }
+    // 21: uint16
+    else if (prop.typeIndex === UINT16) {
+        addField(prop, result.readUint16LE(index), item);
+    }
+    // 22: int32
+    else if (prop.typeIndex === INT32) {
+        addField(prop, result.readInt32LE(index), item);
+    }
+    // 5: uint32
+    else if (prop.typeIndex === UINT32) {
+        addField(prop, result.readUint32LE(index), item);
+    }
+};
+const readMain = (q, result, offset, item) => {
+    const mainInclude = q.include.main;
+    let i = offset;
+    if (mainInclude.len === q.schema.mainLen) {
+        for (const start in q.schema.main) {
+            readMainValue(q.schema.main[start], result, Number(start) + i, item);
+        }
+        i += q.schema.mainLen;
+    }
+    else {
+        for (const k in mainInclude.include) {
+            const [index, prop] = mainInclude.include[k];
+            readMainValue(prop, result, index + i, item);
+        }
+        i += mainInclude.len;
+    }
+    return i - offset;
+};
+const handleUndefinedProps = (id, q, item) => {
+    for (const k in q.include.propsRead) {
+        if (q.include.propsRead[k] !== id) {
+            addField(q.schema.reverseProps[k], '', item);
+        }
+    }
+};
+export const readAllFields = (q, result, offset, end, item, id) => {
+    let i = offset;
+    while (i < end) {
+        const index = result[i];
+        i++;
+        if (index === 255) {
+            handleUndefinedProps(id, q, item);
+            return i - offset;
+        }
+        if (index === 252) {
+            let prop = result[i];
+            if (prop === 254) {
+                i++;
+                const field = result[i];
+                i++;
+                const size = result.readUint32LE(i);
+                i += 4;
+                const ref = q.edges.references.get(field);
+                if (size === 0) {
+                    // @ts-ignore
+                    addField(ref.target.propDef, null, item);
+                    i += size;
+                }
+                else {
+                    i++;
+                    let id = result.readUInt32LE(i);
+                    i += 4;
+                    const refItem = {
+                        id,
+                    };
+                    readAllFields(ref, result, i, size + i - 5, refItem, id);
+                    // @ts-ignore
+                    addField(ref.target.propDef, refItem, item);
+                    i += size - 5;
+                }
+            }
+            else if (prop === 253) {
+                i++;
+                const field = result[i];
+                i++;
+                const ref = q.edges.references.get(field);
+                const size = result.readUint32LE(i);
+                i += 4;
+                const refs = resultToObject(ref, result, size + i + 4, i);
+                // @ts-ignore
+                addField(ref.target.propDef, refs, item);
+                i += size + 4;
+                // ----------------
+            }
+            else {
+                const edgeDef = q.edges.reverseProps[prop];
+                const t = edgeDef.typeIndex;
+                if (t === BINARY) {
+                    i++;
+                    const size = result.readUint32LE(i);
+                    addField(edgeDef, new Uint8Array(result.buffer, i + 6, size - 6), item);
+                    i += size + 4;
+                }
+                else if (t === STRING || t === ALIAS || t === ALIASES) {
+                    i++;
+                    const size = result.readUint32LE(i);
+                    if (size === 0) {
+                        addField(edgeDef, '', item);
+                    }
+                    else {
+                        addField(edgeDef, read(result, i + 4, size), item);
+                    }
+                    i += size + 4;
+                }
+                else {
+                    i++;
+                    readMainValue(edgeDef, result, i, item);
+                    i += edgeDef.len;
+                }
+            }
+        }
+        else if (index === 254) {
+            const field = result[i];
+            i++;
+            const size = result.readUint32LE(i);
+            i += 4;
+            const ref = q.references.get(field);
+            if (size === 0) {
+                // @ts-ignore
+                addField(ref.target.propDef, null, item);
+                i += size;
+            }
+            else {
+                i++;
+                let id = result.readUInt32LE(i);
+                i += 4;
+                const refItem = {
+                    id,
+                };
+                readAllFields(ref, result, i, size + i - 5, refItem, id);
+                // @ts-ignore
+                addField(ref.target.propDef, refItem, item);
+                i += size - 5;
+            }
+        }
+        else if (index === 253) {
+            const field = result[i];
+            i++;
+            const ref = q.references.get(field);
+            const size = result.readUint32LE(i);
+            i += 4;
+            const refs = resultToObject(ref, result, size + i + 4, i);
+            // @ts-ignore
+            addField(ref.target.propDef, refs, item);
+            i += size + 4;
+        }
+        else if (index === 0) {
+            i += readMain(q, result, i, item);
+        }
+        else {
+            const prop = q.schema.reverseProps[index];
+            if (prop.typeIndex === BINARY) {
+                q.include.propsRead[index] = id;
+                const size = result.readUint32LE(i);
+                addField(prop, new Uint8Array(result.buffer, i + 4 + 2, size - 6), item);
+                i += size + 4;
+            }
+            else if (prop.typeIndex === STRING) {
+                q.include.propsRead[index] = id;
+                const size = result.readUint32LE(i);
+                if (size === 0) {
+                    addField(prop, '', item);
+                }
+                else {
+                    addField(prop, read(result, i + 4, size), item);
+                }
+                i += size + 4;
+            }
+            else if (prop.typeIndex == TEXT) {
+                q.include.propsRead[index] = id;
+                const size = result.readUint32LE(i);
+                // TODO Read text
+                //if (size === 0) {
+                //  addField(prop, '', item)
+                //} else {
+                //  addField(prop, read(result, i + 4, size), item)
+                //}
+                i += size + 4;
+            }
+            else if (prop.typeIndex === ALIAS) {
+                q.include.propsRead[index] = id;
+                const size = result.readUint32LE(i);
+                i += 4;
+                if (size === 0) {
+                    addField(prop, '', item);
+                }
+                else {
+                    const string = result.toString('utf8', i, (i += size));
+                    addField(prop, string, item);
+                }
+            }
+        }
+    }
+    // to add defaults - may not optimal for performance
+    handleUndefinedProps(id, q, item);
+    return i - offset;
+};
+export const resultToObject = (q, result, end, offset = 0) => {
+    const len = result.readUint32LE(offset);
+    if (len === 0) {
+        return [];
+    }
+    let items = [];
+    let i = 5 + offset;
+    while (i < end) {
+        let id = result.readUInt32LE(i);
+        i += 4;
+        const item = {
+            id,
+        };
+        if (q.search) {
+            item.$searchScore = result[i];
+            i += 1;
+        }
+        const l = readAllFields(q, result, i, end, item, id);
+        i += l;
+        items.push(item);
+    }
+    if ('id' in q.target || 'alias' in q.target) {
+        return items[0];
+    }
+    return items;
+};
+//# sourceMappingURL=read.js.map

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

@@ -0,0 +1,2 @@
+import { BasedDbQuery } from './BasedDbQuery.js';
+export declare const registerQuery: (q: BasedDbQuery) => Buffer;

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

@@ -0,0 +1,31 @@
+import native from '../../native.js';
+import { defToBuffer } from './toBuffer.js';
+import { checkMaxBufferSize } from './validation.js';
+export const registerQuery = (q) => {
+    // just add crc32 in the buffer
+    if (!q.id) {
+        const b = defToBuffer(q.db, q.def);
+        const buf = Buffer.concat(b);
+        let id = native.crc32(buf);
+        q.id = id;
+        //   id = (id ^ q.def.schema.id) >>> 0
+        // typeId, crc32, len
+        // but want it to fit in a js number...
+        // use 2 bytes for len and just continue counting
+        //   const x = Buffer.allocUnsafe(8)
+        //   // const number
+        //   x.writeUint16LE(q.def.schema.id, 0)
+        //   x.writeUint32LE(id, 2)
+        //   x.writeUint16LE(buf.byteLength, 6)
+        //   // ------------------------
+        //   console.log('-> CRC32', { id, x: new Uint8Array(x), y: x.readFloatLE(0) })
+        // do a test for
+        //   console.log(id)
+        // id, len, type as id?
+        q.buffer = buf;
+        checkMaxBufferSize(buf);
+        return buf;
+    }
+    return q.buffer;
+};
+//# sourceMappingURL=registerQuery.js.map

package/dist/src/client/query/search/index.d.ts

@@ -0,0 +1,6 @@
+import { QueryDefSearch, QueryDef } from '../types.js';
+export type Search = string[] | {
+    [field: string]: number;
+} | string;
+export declare const search: (def: QueryDef, q: string, s?: Search) => void;
+export declare const searchToBuffer: (search: QueryDefSearch) => Buffer;

package/dist/src/client/query/search/index.js

@@ -0,0 +1,82 @@
+import { STRING } from '../../../server/schema/types.js';
+const makeSize = (nr, u8 = false) => {
+    if (u8) {
+        const size = Buffer.allocUnsafe(1);
+        size[0] = nr;
+        return size;
+    }
+    const size = Buffer.allocUnsafe(2);
+    size.writeUint16LE(nr);
+    return size;
+};
+export const search = (def, q, s) => {
+    let blocks = 0;
+    const x = q.toLowerCase().trim().split(' ');
+    const bufs = [];
+    for (const s of x) {
+        if (s) {
+            const b = Buffer.from(s);
+            bufs.push(makeSize(b.byteLength), b);
+            blocks++;
+        }
+    }
+    bufs.unshift(makeSize(blocks, true));
+    const query = Buffer.concat(bufs);
+    def.search = {
+        size: query.byteLength + 2,
+        query,
+        fields: [],
+    };
+    if (typeof s === 'string') {
+        s = [s];
+    }
+    if (!s) {
+        s = {};
+        for (const k in def.props) {
+            const prop = def.props[k];
+            // if title / name / headline add ROLE:
+            if (prop.typeIndex === STRING) {
+                s[k] = k === 'title' || k === 'name' || k === 'headline' ? 0 : 2;
+            }
+        }
+    }
+    else if (Array.isArray(s)) {
+        const x = {};
+        for (const f of s) {
+            x[f] = 0;
+        }
+        s = x;
+    }
+    for (const key in s) {
+        const prop = def.props[key];
+        if (!prop) {
+            throw new Error('field ' + key + ' does not exist on type');
+        }
+        if (prop.typeIndex !== STRING) {
+            throw new Error('Can only search trough strings');
+        }
+        def.search.size += 4;
+        def.search.fields.push({
+            weight: s[key],
+            field: prop.prop,
+            start: prop.start ?? 0,
+        });
+    }
+};
+export const searchToBuffer = (search) => {
+    const result = Buffer.allocUnsafe(search.size);
+    result.writeUint16LE(search.query.byteLength, 0);
+    result.set(search.query, 2);
+    const offset = search.query.byteLength + 2;
+    search.fields.sort((a, b) => {
+        return a.weight - b.weight;
+    });
+    for (let i = 0; i < search.fields.length * 4; i += 4) {
+        const f = search.fields[i / 4];
+        result[i + offset] = f.field;
+        result[i + 1 + offset] = f.weight;
+        result.writeUInt16LE(f.start, i + 2 + offset);
+    }
+    return result;
+};
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,3 @@
+import { QueryDef, QueryDefSort } from './types.js';
+export declare const createSortBuffer: (sort: QueryDefSort) => Buffer;
+export declare const sort: (def: QueryDef, field: string, order?: "asc" | "desc") => void;

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

@@ -0,0 +1,18 @@
+export const createSortBuffer = (sort) => {
+    const buf = Buffer.allocUnsafe(7);
+    // [order] [propType] [start] [start] [len] [len]
+    buf[0] = sort.order;
+    buf[1] = sort.prop.prop;
+    buf[2] = sort.prop.typeIndex;
+    buf.writeUint16LE(sort.prop.start, 3);
+    buf.writeUint16LE(sort.prop.len, 5);
+    return buf;
+};
+// NO REF / REFERENCES SUPPORT
+export const sort = (def, field, order) => {
+    def.sort = {
+        prop: def.props[field],
+        order: order === 'asc' || order === undefined ? 0 : 1,
+    };
+};
+//# sourceMappingURL=sort.js.map

package/dist/src/client/query/subscription/index.d.ts

@@ -0,0 +1,5 @@
+import { BasedDbQuery } from '../BasedDbQuery.js';
+import { OnData, OnError, OnClose } from './types.js';
+export * from './types.js';
+export * from './markers.js';
+export declare const subscribe: (q: BasedDbQuery, onData: OnData, onError: OnError) => OnClose;