@based/db 0.0.1

package/dist/src/client/modify/upsert.js

@@ -0,0 +1,40 @@
+import { ALIAS } from '../../server/schema/types.js';
+export async function upsert(db, type, obj) {
+    const tree = db.schemaTypesParsed[type].tree;
+    let q;
+    let id = '';
+    for (const key in obj) {
+        if (tree[key].typeIndex === ALIAS) {
+            id += `${key}:${obj[key]};`;
+            if (q) {
+                q = q.or(key, '=', obj[key]);
+            }
+            else {
+                q = db.query(type).include('id').filter(key, '=', obj[key]);
+            }
+        }
+    }
+    if (!q) {
+        throw new Error('no alias found for upsert operation');
+    }
+    if (db.upserting.has(id)) {
+        const store = db.upserting.get(id);
+        store.o = { ...store.o, ...obj };
+        return store.p;
+    }
+    const store = {
+        o: obj,
+        p: q.get().then((res) => {
+            db.upserting.delete(id);
+            if (res.length === 0) {
+                return db.create(type, store.o);
+            }
+            else {
+                return db.update(type, res.toObject()[0].id, store.o);
+            }
+        }),
+    };
+    db.upserting.set(id, store);
+    return store.p;
+}
+//# sourceMappingURL=upsert.js.map

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

@@ -0,0 +1,31 @@
+import { PropDef, SchemaTypeDef } from '../server/schema/types.js';
+import { DbClient } from './index.js';
+import { ModifyState } from './modify/ModifyRes.js';
+export declare class ModifyCtx {
+    constructor(db: DbClient);
+    len: number;
+    id: number;
+    lastMain: number;
+    hasStringField: number;
+    queue: Map<(payload: any) => void, ModifyState>;
+    ctx: {
+        offsets?: Record<number, number>;
+    };
+    payload: Buffer;
+    max: number;
+    buf: Buffer;
+    field: number;
+    prefix0: number;
+    prefix1: number;
+    mergeMain: (PropDef | any)[] | null;
+    mergeMainSize: number;
+    db: DbClient;
+    dirtyRanges: Set<number>;
+    dirtyTypes: Map<number, number>;
+    markNodeDirty(schema: SchemaTypeDef, nodeId: number): void;
+    markTypeDirty(schema: SchemaTypeDef): void;
+    updateMax(): void;
+    getData(): Buffer;
+}
+export declare const flushBuffer: (db: DbClient) => Promise<void>;
+export declare const startDrain: (db: DbClient) => void;

package/dist/src/client/operations.js

@@ -0,0 +1,110 @@
+import { makeCsmtKeyFromNodeId } from './tree.js';
+export class ModifyCtx {
+    constructor(db) {
+        this.max = db.maxModifySize;
+        this.db = db;
+        this.buf = Buffer.allocUnsafe(db.maxModifySize);
+    }
+    // default values
+    len = 0;
+    id = -1;
+    lastMain = -1;
+    hasStringField = -1;
+    queue = new Map();
+    ctx = {}; // maybe make this different?
+    payload;
+    max;
+    buf;
+    field;
+    prefix0 = -1;
+    prefix1 = -1;
+    mergeMain;
+    mergeMainSize;
+    db;
+    dirtyRanges = new Set();
+    dirtyTypes = new Map();
+    markNodeDirty(schema, nodeId) {
+        const key = makeCsmtKeyFromNodeId(schema.id, schema.blockCapacity, nodeId);
+        if (this.dirtyRanges.has(key)) {
+            return;
+        }
+        this.dirtyRanges.add(key);
+        this.updateMax();
+    }
+    markTypeDirty(schema) {
+        if (this.dirtyTypes.has(schema.id)) {
+            return;
+        }
+        this.dirtyTypes.set(schema.id, schema.lastId);
+        this.updateMax();
+    }
+    updateMax() {
+        // reserve space in the end of the buf [...data, type (16), lastId (32), typesSize (16), ...ranges (64)[], dataLen (32)]
+        this.max =
+            this.db.maxModifySize -
+                4 -
+                2 -
+                this.dirtyTypes.size * 10 -
+                this.dirtyRanges.size * 8;
+    }
+    getData() {
+        const rangesSize = this.dirtyRanges.size;
+        const typesSize = this.dirtyTypes.size;
+        const data = this.buf.subarray(0, this.len + 4 + 2 + typesSize * 10 + rangesSize * 8);
+        let i = this.len;
+        data.writeUint16LE(typesSize, i);
+        i += 2;
+        for (const [id, startId] of this.dirtyTypes) {
+            const lastId = this.db.schemaTypesParsedById[id].lastId;
+            data.writeUint16LE(id, i);
+            i += 2;
+            data.writeUint32LE(startId, i);
+            i += 4;
+            data.writeUint32LE(lastId, i);
+            i += 4;
+        }
+        for (let key of this.dirtyRanges) {
+            data.writeDoubleLE(key, i);
+            i += 8;
+        }
+        data.writeUint32LE(this.len, i);
+        return data;
+    }
+}
+export const flushBuffer = (db) => {
+    const ctx = db.modifyCtx;
+    let flushPromise;
+    if (ctx.len) {
+        const d = Date.now();
+        const data = ctx.getData();
+        const resCtx = ctx.ctx;
+        const queue = ctx.queue;
+        flushPromise = db.hooks.flushModify(data).then(({ offsets }) => {
+            resCtx.offsets = offsets;
+            db.writeTime += Date.now() - d;
+            if (queue.size) {
+                flushPromise.then(() => {
+                    for (const [resolve, res] of queue) {
+                        resolve(res.getId(offsets));
+                    }
+                });
+            }
+        });
+        ctx.dirtyTypes.clear();
+        ctx.dirtyRanges.clear();
+        ctx.len = 0;
+        ctx.prefix0 = -1;
+        ctx.prefix1 = -1;
+        ctx.max = db.maxModifySize;
+        ctx.ctx = {};
+    }
+    db.isDraining = false;
+    return flushPromise;
+};
+export const startDrain = (db) => {
+    db.isDraining = true;
+    process.nextTick(() => {
+        flushBuffer(db);
+    });
+};
+//# sourceMappingURL=operations.js.map

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

@@ -0,0 +1,40 @@
+import { QueryDef, Operator, QueryByAliasObj } from './query.js';
+import { BasedQueryResponse } from './BasedIterable.js';
+import { FilterAst, FilterBranchFn } from './filter/types.js';
+import { Search } from './search/index.js';
+import { OnData, OnError } from './subscription/index.js';
+import { DbClient } from '../index.js';
+export { QueryByAliasObj };
+export type SelectFn = (field: string) => BasedDbReferenceQuery;
+export type BranchInclude = (select: SelectFn) => any;
+export declare class QueryBranch<T> {
+    db: DbClient;
+    def: QueryDef;
+    constructor(db: DbClient, def: QueryDef);
+    sort(field: string, order?: 'asc' | 'desc'): T;
+    filter(field: string, operator?: Operator | boolean, value?: any): T;
+    search(query: string, ...fields: Search[]): T;
+    filterBatch(f: FilterAst): this;
+    or(fn: FilterBranchFn): T;
+    or(field: string, operator?: Operator | boolean, value?: any): T;
+    range(offset: number, limit: number): T;
+    include(...fields: (string | BranchInclude | string[])[]): T;
+}
+export declare class BasedDbReferenceQuery extends QueryBranch<BasedDbReferenceQuery> {
+}
+declare class GetPromise extends Promise<BasedQueryResponse> {
+    toObject(): Promise<any>;
+    toJSON(): Promise<string>;
+    inspect(): GetPromise;
+}
+export declare class BasedDbQuery extends QueryBranch<BasedDbQuery> {
+    #private;
+    constructor(db: DbClient, type: string, id?: QueryByAliasObj | number | (QueryByAliasObj | number)[]);
+    id: number;
+    get(): GetPromise;
+    buffer: Buffer;
+    register(): Buffer;
+    subscribe(onData: OnData, onError?: OnError): import("./subscription/types.js").OnClose;
+    _getSync(dbCtxExternal: any): BasedQueryResponse;
+    toBuffer(): Buffer;
+}

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

@@ -0,0 +1,235 @@
+import { createQueryDef, QueryDefType, includeFields, filter, sort, defToBuffer, getAll, filterOr, convertFilter, isAlias, } from './query.js';
+import { BasedQueryResponse } from './BasedIterable.js';
+import { createOrGetEdgeRefQueryDef, createOrGetRefQueryDef, } from './include/utils.js';
+import { FilterBranch } from './filter/FilterBranch.js';
+import { search } from './search/index.js';
+import { isValidId, checkMaxIdsPerQuery, checkTotalBufferSize, hasField, hasFields, } from './validation.js';
+import native from '../../native.js';
+import { REFERENCE, REFERENCES } from '../../server/schema/types.js';
+import { subscribe } from './subscription/index.js';
+import { registerQuery } from './registerQuery.js';
+export class QueryBranch {
+    db;
+    def;
+    constructor(db, def) {
+        this.db = db;
+        this.def = def;
+    }
+    sort(field, order = 'asc') {
+        sort(this.def, field, order);
+        // @ts-ignore
+        return this;
+    }
+    filter(field, operator, value) {
+        const f = convertFilter(field, operator, value);
+        filter(this.db, this.def, f, this.def.filter);
+        // @ts-ignore
+        return this;
+    }
+    search(query, ...fields) {
+        if (fields.length) {
+            if (fields.length === 1) {
+                search(this.def, query, fields[0]);
+            }
+            else {
+                const s = {};
+                for (const f of fields) {
+                    if (typeof f === 'string') {
+                        s[f] = 0;
+                    }
+                    else if (Array.isArray(f)) {
+                        for (const ff of f) {
+                            s[ff] = 0;
+                        }
+                    }
+                    else if (typeof f === 'object') {
+                        Object.assign(s, f);
+                    }
+                }
+                search(this.def, query, s);
+            }
+        }
+        else {
+            search(this.def, query);
+        }
+        // @ts-ignore
+        return this;
+    }
+    filterBatch(f) {
+        filter(this.db, this.def, f, this.def.filter);
+        // @ts-ignore
+        return this;
+    }
+    or(field, operator, value) {
+        if (typeof field === 'function') {
+            const f = new FilterBranch(this.db, filterOr(this.db, this.def, [], this.def.filter), 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.def.filter);
+        }
+        // @ts-ignore
+        return this;
+    }
+    range(offset, limit) {
+        this.def.range.offset = offset;
+        this.def.range.limit = limit;
+        // @ts-ignore
+        return this;
+    }
+    include(...fields) {
+        for (const f of fields) {
+            if (typeof f === 'string') {
+                if (f === '*') {
+                    hasFields(this.def.props);
+                    includeFields(this.def, getAll(this.def.props));
+                }
+                else {
+                    this.def.include.stringFields.add(f);
+                }
+            }
+            else if (typeof f === 'function') {
+                f((field) => {
+                    if (field[0] == '$') {
+                        // @ts-ignore
+                        const prop = this.def.target?.propDef?.edges[field];
+                        if (prop &&
+                            (prop.typeIndex === REFERENCE || prop.typeIndex === REFERENCES)) {
+                            const refDef = createOrGetEdgeRefQueryDef(this.db, this.def, prop);
+                            // @ts-ignore
+                            return new QueryBranch(this.db, refDef);
+                        }
+                        throw new Error(`No edge reference or edge references field named "${field}"`);
+                    }
+                    else {
+                        const prop = field[0] == '$'
+                            ? // @ts-ignore
+                                this.def.target?.propDef?.edges[field]
+                            : this.def.props[field];
+                        if (prop &&
+                            (prop.typeIndex === REFERENCE || prop.typeIndex === REFERENCES)) {
+                            const refDef = createOrGetRefQueryDef(this.db, this.def, prop);
+                            // @ts-ignore
+                            return new QueryBranch(this.db, refDef);
+                        }
+                        throw new Error(`No reference or references field named "${field}"`);
+                    }
+                });
+            }
+            else if (Array.isArray(f)) {
+                for (const field of f) {
+                    hasField(field);
+                }
+                includeFields(this.def, f);
+            }
+            else if (f !== undefined) {
+                throw new Error('Invalid include statement: expected props, refs and edges (string or array) or function');
+            }
+        }
+        // @ts-ignore
+        return this;
+    }
+}
+export class BasedDbReferenceQuery extends QueryBranch {
+}
+const resToJSON = (res) => res.toJSON();
+const resToObject = (res) => res.toObject();
+const resInspect = (res) => new GetPromise((resolve) => resolve(res.inspect()));
+class GetPromise extends Promise {
+    toObject() {
+        return this.then(resToObject);
+    }
+    toJSON() {
+        return this.then(resToJSON);
+    }
+    inspect() {
+        return this.then(resInspect);
+    }
+}
+export class BasedDbQuery extends QueryBranch {
+    constructor(db, type, id) {
+        const target = {
+            type,
+        };
+        if (id) {
+            if (isAlias(id)) {
+                target.alias = id;
+            }
+            else {
+                if (Array.isArray(id)) {
+                    checkMaxIdsPerQuery(id);
+                    // const ids = id.filter((id) => typeof id === 'number')
+                    // if (ids.length < id.length) {
+                    //   throw new Error(
+                    //     'Seems that aliases are part of ids in qeury not supported yet...',
+                    //   )
+                    // }
+                    // TODO ADD MULTI ALIAS
+                    // @ts-ignore
+                    target.ids = new Uint32Array(id);
+                    for (const id of target.ids) {
+                        isValidId(id);
+                    }
+                    target.ids.sort();
+                }
+                else {
+                    isValidId(id);
+                    target.id = id;
+                }
+            }
+        }
+        const def = createQueryDef(db, QueryDefType.Root, target);
+        super(db, def);
+    }
+    #getInternal = async (resolve, reject) => {
+        if (!this.def.include.stringFields.size && !this.def.references.size) {
+            includeFields(this.def, ['*']);
+        }
+        const buf = registerQuery(this);
+        const d = performance.now();
+        const res = await this.db.hooks.getQueryBuf(buf);
+        if (res instanceof Error) {
+            reject(res);
+        }
+        else {
+            const result = Buffer.from(res);
+            resolve(new BasedQueryResponse(this.id, this.def, result, performance.now() - d));
+        }
+    };
+    // if !id not initialized yet
+    id;
+    get() {
+        return new GetPromise(this.#getInternal);
+    }
+    buffer;
+    register() {
+        return registerQuery(this);
+    }
+    subscribe(onData, onError) {
+        return subscribe(this, onData, onError ??
+            ((err) => {
+                console.error(err);
+            }));
+    }
+    _getSync(dbCtxExternal) {
+        if (!this.def.include.stringFields.size && !this.def.references.size) {
+            includeFields(this.def, ['*']);
+        }
+        const buf = registerQuery(this);
+        const d = performance.now();
+        const res = native.getQueryBuf(buf, dbCtxExternal);
+        const result = Buffer.from(res);
+        return new BasedQueryResponse(this.id, this.def, result, performance.now() - d);
+    }
+    toBuffer() {
+        if (!this.def.include.stringFields.size && !this.def.references.size) {
+            includeFields(this.def, ['*']);
+        }
+        const b = defToBuffer(this.db, this.def);
+        checkTotalBufferSize(b);
+        return Buffer.concat(b);
+    }
+}
+//# sourceMappingURL=BasedDbQuery.js.map

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

@@ -0,0 +1,26 @@
+import { inspect } from 'node:util';
+import { QueryDef } from './types.js';
+import { Item } from './query.js';
+import { size, time, inspectData } from './display.js';
+export { time, size, inspectData };
+export declare class BasedQueryResponse {
+    result: Buffer;
+    def: QueryDef;
+    execTime: number;
+    end: number;
+    id: number;
+    constructor(id: number, def: QueryDef, result: Buffer, execTime: number, end?: number);
+    get size(): number;
+    [inspect.custom](depth: number): string;
+    debug(): this;
+    node(index?: number): any;
+    [Symbol.iterator](): Generator<Item, void, unknown>;
+    inspect(depth?: number): this;
+    forEach(fn: (item: any, key: number) => void): void;
+    map(fn: (item: any, key: number) => any): any[];
+    get checksum(): number;
+    get length(): number;
+    toObject(): any;
+    toJSON(): string;
+    toString(): string;
+}

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

@@ -0,0 +1,113 @@
+import { inspect } from 'node:util';
+import picocolors from 'picocolors';
+import { debug, resultToObject, readAllFields } from './query.js';
+import { size, time, inspectData } from './display.js';
+export { time, size, inspectData };
+export class BasedQueryResponse {
+    result;
+    def;
+    execTime;
+    end;
+    id;
+    constructor(id, def, result, execTime, end = result.byteLength) {
+        this.id = id;
+        this.def = def;
+        this.result = result;
+        this.execTime = execTime;
+        this.end = end;
+    }
+    get size() {
+        return this.result.byteLength;
+    }
+    [inspect.custom](depth) {
+        const hasId = 'id' in this.def.target || 'alias' in this.def.target;
+        const target = hasId
+            ? this.def.schema.type +
+                ':' +
+                ('alias' in this.def.target
+                    ? inspect(this.def.target.alias)
+                    : // @ts-ignore
+                        this.def.target.id)
+            : this.def.schema.type;
+        let str = '';
+        str += '\n  execTime: ' + time(this.execTime);
+        str += '\n  size: ' + size(this.result.byteLength);
+        const dataStr = inspectData(this, this.def, 0, true, hasId && depth == 2 ? 5 : depth, hasId);
+        str += '\n';
+        str += dataStr;
+        return `${picocolors.bold(`BasedQueryResponse[${target}]`)} {${str}\n}\n`;
+    }
+    debug() {
+        debug(this.result, 0, this.end);
+        return this;
+    }
+    node(index = 0) {
+        let i = 0;
+        if ('id' in this.def.target || 'alias' in this.def.target) {
+            return this.toObject();
+        }
+        if (index < 0) {
+            index = this.length + index;
+        }
+        for (const x of this) {
+            if (i === index) {
+                return x;
+            }
+            i++;
+        }
+        return null;
+    }
+    *[Symbol.iterator]() {
+        let i = 5;
+        const result = this.result;
+        while (i < result.byteLength - 4) {
+            let id = result.readUInt32LE(i);
+            i += 4;
+            const item = {
+                id,
+            };
+            if (this.def.search) {
+                item.$searchScore = result[i];
+                i += 1;
+            }
+            const l = readAllFields(this.def, result, i, result.byteLength - 4, item, id);
+            i += l;
+            yield item;
+        }
+    }
+    inspect(depth = 2) {
+        console.log(this[inspect.custom](depth));
+        return this;
+    }
+    forEach(fn) {
+        let i = 0;
+        for (const item of this) {
+            fn(item, ++i);
+        }
+    }
+    map(fn) {
+        const arr = new Array(this.length);
+        let i = 0;
+        for (const item of this) {
+            arr[i++] = fn(item, i);
+        }
+        return arr;
+    }
+    get checksum() {
+        return this.result.readUint32LE(this.result.byteLength - 4);
+    }
+    get length() {
+        return this.result.readUint32LE(0);
+    }
+    toObject() {
+        return resultToObject(this.def, this.result, this.end - 4, 0);
+    }
+    toJSON() {
+        // TODO: optimize
+        return JSON.stringify(this.toObject());
+    }
+    toString() {
+        return this.toJSON();
+    }
+}
+//# sourceMappingURL=BasedIterable.js.map

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

@@ -0,0 +1,3 @@
+import { QueryDef } from './types.js';
+export declare const debugQueryDef: (q: QueryDef, returnIt?: boolean) => any;
+export declare const debug: (x: any, start?: number, end?: number, label?: string) => void;