@based/db 0.0.1

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

@@ -0,0 +1,88 @@
+import { PropDef, PropDefEdge, SchemaTypeDef } from '../../server/schema/schema.js';
+export type MainIncludes = {
+    [start: string]: [number, PropDef];
+};
+export type IncludeTreeArr = (string | PropDef | IncludeTreeArr)[];
+declare enum QueryDefType {
+    Edge = 1,
+    Reference = 2,
+    References = 3,
+    Root = 4
+}
+export type EdgeTarget = {
+    ref: PropDef | PropDefEdge | null;
+};
+export type Target = {
+    type: string;
+    id?: number | void;
+    ids?: Uint32Array | void;
+    propDef?: PropDef | PropDefEdge;
+    alias?: QueryByAliasObj;
+};
+export declare const isRefDef: (def: QueryDef) => def is QueryDefRest;
+export type QueryDefFilter = {
+    size: number;
+    conditions: Map<number, Buffer[]>;
+    references?: Map<number, QueryDefFilter>;
+    fromRef?: PropDef;
+    schema?: SchemaTypeDef;
+    edges?: Map<number, Buffer[]>;
+    or?: QueryDefFilter;
+    and?: QueryDefFilter;
+};
+export type QueryDefSearch = {
+    size: number;
+    query: Buffer;
+    fields: {
+        weight: number;
+        field: number;
+        start: number;
+    }[];
+};
+export type QueryDefSort = {
+    prop: PropDefEdge | PropDef;
+    order: 0 | 1;
+};
+export type QueryDefShared = {
+    filter: QueryDefFilter;
+    search: null | QueryDefSearch;
+    sort: null | QueryDefSort;
+    reverseProps: any;
+    range: {
+        offset: number;
+        limit: number;
+    };
+    include: {
+        stringFields: Set<string>;
+        props: Set<number>;
+        propsRead: {
+            [propName: number]: number;
+        };
+        main: {
+            include: MainIncludes;
+            len: number;
+        };
+    };
+    references: Map<number, QueryDef>;
+    edges?: QueryDef;
+};
+export type QueryDefEdges = {
+    type: QueryDefType.Edge;
+    target: EdgeTarget;
+    schema: null;
+    props: PropDef['edges'];
+    reverseProps: PropDef['edges'];
+} & QueryDefShared;
+export type QueryDefRest = {
+    type: QueryDefType.References | QueryDefType.Reference | QueryDefType.Root;
+    target: Target;
+    schema: SchemaTypeDef | null;
+    props: SchemaTypeDef['props'] | PropDef['edges'];
+} & QueryDefShared;
+export type QueryDef = QueryDefEdges | QueryDefRest;
+export type QueryTarget = EdgeTarget | Target;
+export { QueryDefType };
+export type QueryByAliasObj = {
+    [key: string]: string | QueryByAliasObj;
+};
+export declare const isAlias: (id: QueryByAliasObj | number | (QueryByAliasObj | number)[]) => id is QueryByAliasObj;

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

@@ -0,0 +1,15 @@
+var QueryDefType;
+(function (QueryDefType) {
+    QueryDefType[QueryDefType["Edge"] = 1] = "Edge";
+    QueryDefType[QueryDefType["Reference"] = 2] = "Reference";
+    QueryDefType[QueryDefType["References"] = 3] = "References";
+    QueryDefType[QueryDefType["Root"] = 4] = "Root";
+})(QueryDefType || (QueryDefType = {}));
+export const isRefDef = (def) => {
+    return (def.type === QueryDefType.Reference || def.type === QueryDefType.References);
+};
+export { QueryDefType };
+export const isAlias = (id) => {
+    return typeof id === 'object' && id !== null && !Array.isArray(id);
+};
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1,15 @@
+import { PropDef, PropDefEdge } from '../../server/schema/types.js';
+import { Operator } from './filter/operators.js';
+import { QueryByAliasObj } from './types.js';
+export declare const isValidId: (id: number) => void;
+export declare const checkMaxIdsPerQuery: (ids: (number | QueryByAliasObj)[]) => void;
+export declare const checkMaxBufferSize: (buf: Buffer) => void;
+export declare const checkTotalBufferSize: (bufers: Buffer[]) => void;
+export declare const hasFields: (fields: {
+    [key: string]: PropDefEdge;
+} | {
+    [path: string]: PropDef;
+}) => void;
+export declare const hasField: (field: string) => void;
+export declare const checkOperator: (operator: Operator | boolean) => void;
+export declare const checkValue: (value: any, operator: Operator) => void;

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

@@ -0,0 +1,59 @@
+import { MAX_IDS_PER_QUERY, MIN_ID_VALUE, MAX_ID_VALUE, MAX_BUFFER_SIZE, } from './thresholds.js';
+import { validOperators } from './filter/operators.js';
+export const isValidId = (id) => {
+    if (typeof id != 'number') {
+        throw new Error('Id has to be a number');
+    }
+    else if (id < MIN_ID_VALUE || id > MAX_ID_VALUE) {
+        throw new Error(`Invalid Id: The Id should range between ${MIN_ID_VALUE} and ${MAX_ID_VALUE}.)`);
+    }
+};
+export const checkMaxIdsPerQuery = (ids) => {
+    if (ids.length > MAX_IDS_PER_QUERY) {
+        throw new Error(`The number of IDs cannot exceed ${MAX_IDS_PER_QUERY}.`);
+    }
+};
+export const checkMaxBufferSize = (buf) => {
+    if (buf.byteLength > MAX_BUFFER_SIZE) {
+        throw new Error(`The buffer size exceeds the maximum threshold of ${MAX_BUFFER_SIZE} bytes.` +
+            `Crrent size is ${buf.byteLength} bytes.`);
+    }
+};
+export const checkTotalBufferSize = (bufers) => {
+    let totalSize = 0;
+    for (const buffer of bufers) {
+        totalSize += buffer.byteLength;
+        if (totalSize > MAX_BUFFER_SIZE) {
+            throw new Error(`The total buffer size exceeds the maximum threshold of ${MAX_BUFFER_SIZE} bytes.` +
+                `Crrent size is ${totalSize} bytes.`);
+        }
+    }
+};
+export const hasFields = (fields) => {
+    if (Object.keys(fields).length === 0) {
+        throw new Error('No fields available to include');
+    }
+};
+export const hasField = (field) => {
+    if (!field) {
+        throw new Error(`Invalid field: ${field}`);
+    }
+    else if (typeof field !== 'string' || field.trim() === '') {
+        throw new Error('Field must be a non-empty string');
+    }
+};
+export const checkOperator = (operator) => {
+    if (operator !== undefined &&
+        typeof operator !== 'boolean' &&
+        !validOperators.includes(operator)) {
+        throw new Error(`Invalid operator: ${operator}`);
+    }
+};
+export const checkValue = (value, operator) => {
+    if (operator === '..' || operator === '!..') {
+        if (!Array.isArray(value) || value.length !== 2) {
+            throw new Error(`Invalid value for operator ${operator}: expected an array with two elements`);
+        }
+    }
+};
+//# sourceMappingURL=validation.js.map

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

@@ -0,0 +1,5 @@
+import { LangCode } from '@based/schema';
+export declare const write: (buf: Buffer, value: string, offset: number, noCompression: boolean, lang?: LangCode) => number;
+export declare const compress: (str: string) => Buffer;
+export declare const decompress: (buf: Buffer) => string;
+export declare const read: (buf: Buffer, offset: number, len: number) => string;

package/dist/src/client/string.js

@@ -0,0 +1,73 @@
+import native from '../native.js';
+// type 0 = no compression; 1 = deflate
+// [lang] [type] [uncompressed size 4] [compressed string] [crc32]
+// var cnt = 0
+// var bytesSaved = 0
+// make this into a package
+// write the type Byte
+export const write = (buf, value, offset, noCompression, lang) => {
+    value = value.normalize('NFKD');
+    buf[offset] = lang || 0;
+    // 50 maybe if lvl 1
+    if (value.length > 200 && !noCompression) {
+        const s = Buffer.byteLength(value, 'utf8');
+        buf.write(value, offset + 6 + s, 'utf8');
+        let crc = native.crc32(buf.subarray(offset + 6 + s, offset + 6 + 2 * s));
+        const size = native.compress(buf, offset + 6, s);
+        if (size === 0) {
+            buf[offset + 1] = 0; // not compressed
+            const len = buf.write(value, offset + 2, 'utf8');
+            buf[offset + len + 2] = crc;
+            buf[offset + len + 3] = crc >>>= 8;
+            buf[offset + len + 4] = crc >>>= 8;
+            buf[offset + len + 5] = crc >>>= 8;
+            return len + 6;
+        }
+        else {
+            buf[offset + 1] = 1; // compressed
+            buf.writeUInt32LE(s, offset + 2);
+            buf[offset + size + 6] = crc;
+            buf[offset + size + 7] = crc >>>= 8;
+            buf[offset + size + 8] = crc >>>= 8;
+            buf[offset + size + 9] = crc >>>= 8;
+            return size + 10; // 0 C 4 4
+        }
+    }
+    else {
+        buf[offset + 1] = 0; // not compressed
+        const len = buf.write(value, offset + 2, 'utf8');
+        let crc = native.crc32(buf.subarray(offset + 2, offset + len + 2));
+        buf[offset + len + 2] = crc;
+        buf[offset + len + 3] = crc >>>= 8;
+        buf[offset + len + 4] = crc >>>= 8;
+        buf[offset + len + 5] = crc >>>= 8;
+        return len + 6;
+    }
+};
+let tmpCompressBlock;
+export const compress = (str) => {
+    if (!tmpCompressBlock || tmpCompressBlock.byteLength < str.length * 3) {
+        tmpCompressBlock = Buffer.allocUnsafe(str.length * 3);
+    }
+    const s = write(tmpCompressBlock, str, 0, false);
+    const nBuffer = Buffer.allocUnsafe(s);
+    tmpCompressBlock.copy(nBuffer, 0, 0, s);
+    return nBuffer;
+};
+export const decompress = (buf) => {
+    return read(buf, 0, buf.byteLength);
+};
+export const read = (buf, offset, len) => {
+    const type = buf[offset + 1];
+    if (type == 1) {
+        const origSize = buf.readUint32LE(offset + 2);
+        const newBuffer = Buffer.allocUnsafe(origSize);
+        native.decompress(buf, newBuffer, offset + 6, len - 6);
+        return newBuffer.toString('utf8');
+    }
+    else if (type == 0) {
+        return buf.toString('utf8', offset + 2, len + offset - 4);
+    }
+    return '';
+};
+//# sourceMappingURL=string.js.map

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

@@ -0,0 +1 @@
+export declare const makeCsmtKeyFromNodeId: (typeId: number, blockCapacity: number, nodeId: number) => number;

package/dist/src/client/tree.js

@@ -0,0 +1,5 @@
+export const makeCsmtKeyFromNodeId = (typeId, blockCapacity, nodeId) => {
+    const tmp = nodeId - +!(nodeId % blockCapacity);
+    return typeId * 4294967296 + ((tmp / blockCapacity) | 0) * blockCapacity + 1;
+};
+//# sourceMappingURL=tree.js.map

package/dist/src/index.d.ts

@@ -0,0 +1,31 @@
+import { compress, decompress } from './client/string.js';
+import { ModifyCtx } from './client/operations.js';
+import { DbServer } from './server/index.js';
+import { DbClient } from './client/index.js';
+export * from './server/schema/typeDef.js';
+export * from './client/modify/modify.js';
+export { compress, decompress };
+export { ModifyCtx };
+export { DbClient, DbServer };
+export declare class BasedDb {
+    client: DbClient;
+    server: DbServer;
+    fileSystemPath: string;
+    maxModifySize: number;
+    constructor({ path, maxModifySize, }: {
+        path: string;
+        maxModifySize?: number;
+    });
+    create: DbClient['create'];
+    update: DbClient['update'];
+    upsert: DbClient['upsert'];
+    remove: DbClient['remove'];
+    query: DbClient['query'];
+    putSchema: DbClient['putSchema'];
+    drain: DbClient['drain'];
+    start: DbServer['start'];
+    stop: DbServer['stop'];
+    save: DbServer['save'];
+    migrateSchema: DbServer['migrateSchema'];
+    destroy(): Promise<void>;
+}

package/dist/src/index.js

@@ -0,0 +1,85 @@
+import { compress, decompress } from './client/string.js';
+import { ModifyCtx } from './client/operations.js';
+import { DbServer } from './server/index.js';
+import { DbClient } from './client/index.js';
+export * from './server/schema/typeDef.js';
+export * from './client/modify/modify.js';
+export { compress, decompress };
+export { ModifyCtx }; // TODO move this somewhere
+export { DbClient, DbServer };
+export class BasedDb {
+    client;
+    server;
+    fileSystemPath;
+    maxModifySize;
+    constructor({ path, maxModifySize, }) {
+        const server = new DbServer({
+            path,
+            maxModifySize,
+            onSchemaChange(schema) {
+                client.putLocalSchema(schema);
+            },
+        });
+        const client = new DbClient({
+            maxModifySize,
+            hooks: {
+                putSchema(schema, fromStart) {
+                    return Promise.resolve(server.putSchema(schema, fromStart));
+                },
+                flushModify(buf) {
+                    server.modify(buf);
+                    return Promise.resolve({
+                        offsets: {},
+                    });
+                },
+                getQueryBuf(buf) {
+                    return Promise.resolve(server.getQueryBuf(buf));
+                },
+            },
+        });
+        this.server = server;
+        this.client = client;
+    }
+    // client
+    create = function () {
+        return this.client.create.apply(this.client, arguments);
+    };
+    update = function () {
+        return this.client.update.apply(this.client, arguments);
+    };
+    upsert = function () {
+        return this.client.upsert.apply(this.client, arguments);
+    };
+    remove = function () {
+        return this.client.remove.apply(this.client, arguments);
+    };
+    query = function () {
+        return this.client.query.apply(this.client, arguments);
+    };
+    putSchema = function () {
+        return this.client.putSchema.apply(this.client, arguments);
+    };
+    drain = function () {
+        return this.client.drain.apply(this.client, arguments);
+    };
+    // server
+    start = function () {
+        return this.server.start.apply(this.server, arguments);
+    };
+    stop = function () {
+        this.client.stop();
+        return this.server.stop.apply(this.server, arguments);
+    };
+    save = function () {
+        return this.server.save.apply(this.server, arguments);
+    };
+    migrateSchema = function () {
+        return this.server.migrateSchema.apply(this.server, arguments);
+    };
+    // both
+    destroy() {
+        this.client.destroy();
+        return this.server.destroy();
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/src/native.d.ts

@@ -0,0 +1,28 @@
+declare const _default: {
+    workerCtxInit: () => void;
+    markMerkleBlock: (buf: Buffer) => any;
+    externalFromInt(address: BigInt): any;
+    intFromExternal(external: any): BigInt;
+    modify: (data: Buffer, types: Buffer, dbCtx: any) => any;
+    getQueryBuf: (q: Buffer, dbCtx: any) => Buffer | null;
+    start: (id: number) => any;
+    stop: (dbCtx: any) => any;
+    saveCommon: (path: string, dbCtx: any) => number;
+    saveRange: (path: string, typeCode: number, start: number, end: number, dbCtx: any, hashOut: Buffer) => number;
+    loadCommon: (path: string, dbCtx: any) => number;
+    loadRange: (path: string, dbCtx: any) => number;
+    updateSchemaType: (prefix: number, buf: Buffer, dbCtx: any) => any;
+    getTypeInfo: (typeId: number, dbCtx: any) => any;
+    getNodeRangeHash: (typeId: number, start: number, end: number, bufOut: Buffer, dbCtx: any) => any;
+    createHash: () => {
+        update: (buf: Buffer) => any;
+        digest: (encoding?: BufferEncoding) => Buffer | string;
+        reset: () => void;
+    };
+    compress: (buf: Buffer, offset: number, stringSize: number) => any;
+    decompress: (input: Buffer, output: Buffer, offset: number, len: number) => any;
+    crc32: (buf: Buffer) => any;
+    createSortIndex: (buf: Buffer, dbCtx: any) => any;
+    destroySortIndex: (buf: Buffer, dbCtx: any) => any;
+};
+export default _default;

package/dist/src/native.js

@@ -0,0 +1,96 @@
+// @ts-ignore
+import db from '../../basedDbNative.cjs';
+var compressor = null;
+var decompressor = null;
+export default {
+    workerCtxInit: () => {
+        return db.workerCtxInit();
+    },
+    markMerkleBlock: (buf) => {
+        // pstart,
+    },
+    externalFromInt(address) {
+        return db.externalFromInt(address);
+    },
+    intFromExternal(external) {
+        return db.intFromExternal(external);
+    },
+    modify: (data, types, dbCtx) => {
+        db.modify(data, types, dbCtx);
+    },
+    getQueryBuf: (q, dbCtx) => {
+        return db.getQueryBuf(dbCtx, q);
+    },
+    start: (id) => {
+        return db.start(id);
+    },
+    stop: (dbCtx) => {
+        return db.stop(dbCtx);
+    },
+    saveCommon: (path, dbCtx) => {
+        const buf = Buffer.concat([Buffer.from(path), Buffer.from([0])]);
+        return db.saveCommon(buf, dbCtx);
+    },
+    saveRange: (path, typeCode, start, end, dbCtx, hashOut) => {
+        const buf = Buffer.concat([Buffer.from(path), Buffer.from([0])]);
+        return db.saveRange(buf, typeCode, start, end, dbCtx, hashOut);
+    },
+    loadCommon: (path, dbCtx) => {
+        const buf = Buffer.concat([Buffer.from(path), Buffer.from([0])]);
+        return db.loadCommon(buf, dbCtx);
+    },
+    loadRange: (path, dbCtx) => {
+        const buf = Buffer.concat([Buffer.from(path), Buffer.from([0])]);
+        return db.loadRange(buf, dbCtx);
+    },
+    updateSchemaType: (prefix, buf, dbCtx) => {
+        return db.updateSchema(prefix, buf, dbCtx);
+    },
+    getTypeInfo: (typeId, dbCtx) => {
+        return db.getTypeInfo(typeId, dbCtx);
+    },
+    getNodeRangeHash: (typeId, start, end, bufOut, dbCtx) => {
+        return db.getNodeRangeHash(typeId, start, end, bufOut, dbCtx);
+    },
+    createHash: () => {
+        const state = db.hashCreate();
+        const hash = {
+            update: (buf) => {
+                db.hashUpdate(state, buf);
+                return hash;
+            },
+            digest: (encoding) => {
+                const buf = Buffer.allocUnsafe(16);
+                db.hashDigest(state, buf);
+                return encoding ? buf.toString(encoding) : buf;
+            },
+            reset: () => {
+                db.hashReset(state);
+            },
+        };
+        return hash;
+    },
+    // needs to pass dbCtx: any
+    compress: (buf, offset, stringSize) => {
+        if (compressor === null) {
+            compressor = db.createCompressor();
+        }
+        return db.compress(compressor, buf, offset, stringSize);
+    },
+    decompress: (input, output, offset, len) => {
+        if (decompressor === null) {
+            decompressor = db.createDecompressor();
+        }
+        return db.decompress(decompressor, input, output, offset, len);
+    },
+    crc32: (buf) => {
+        return db.crc32(buf);
+    },
+    createSortIndex: (buf, dbCtx) => {
+        return db.createSortIndex(dbCtx, buf);
+    },
+    destroySortIndex: (buf, dbCtx) => {
+        return db.destroySortIndex(dbCtx, buf);
+    }
+};
+//# sourceMappingURL=native.js.map

package/dist/src/server/csmt/draw-dot.d.ts

@@ -0,0 +1,2 @@
+import { Csmt } from './index.js';
+export default function draw(csmt: Csmt): string;

package/dist/src/server/csmt/draw-dot.js

@@ -0,0 +1,32 @@
+function makeLabel(node) {
+    return `${node.key}\n${node.hash.toString('base64').substring(0, 5)}`;
+}
+export default function draw(csmt) {
+    const root = csmt.getRoot();
+    const lines = [];
+    const nodes = [];
+    let i = 0;
+    const walk = (node, prev) => {
+        const cur = i;
+        const left = node.left;
+        const right = node.right;
+        const isLeaf = !left && !right;
+        nodes.push(`n${cur} [label="${makeLabel(node)}"${isLeaf ? ' shape=box' : ''}];`);
+        if (cur > 0) {
+            lines.push(`n${prev} -- n${cur}`);
+        }
+        if (left) {
+            i++;
+            walk(left, cur);
+        }
+        if (right) {
+            i++;
+            walk(right, cur);
+        }
+    };
+    if (root) {
+        walk(root, i);
+    }
+    return `graph ethane {\n${nodes.join('\n')}\n${lines.join('\n')}\n}`;
+}
+//# sourceMappingURL=draw-dot.js.map

package/dist/src/server/csmt/index.d.ts

@@ -0,0 +1,4 @@
+import drawDot from './draw-dot.js';
+export * from './types.js';
+export * from './tree.js';
+export { drawDot };

package/dist/src/server/csmt/index.js

@@ -0,0 +1,5 @@
+import drawDot from './draw-dot.js';
+export * from './types.js';
+export * from './tree.js';
+export { drawDot };
+//# sourceMappingURL=index.js.map

package/dist/src/server/csmt/match.d.ts

@@ -0,0 +1,7 @@
+type Predicate = (x: any) => boolean;
+type Func = (x: any) => any;
+declare const match: (x: any) => {
+    on: (pred: Predicate, fn: Func) => any;
+    otherwise: (fn: Func) => any;
+};
+export default match;

package/dist/src/server/csmt/match.js

@@ -0,0 +1,10 @@
+const matched = (x) => ({
+    on: () => matched(x),
+    otherwise: () => x,
+});
+const match = (x) => ({
+    on: (pred, fn) => (pred(x) ? matched(fn(x)) : match(x)),
+    otherwise: (fn) => fn(x),
+});
+export default match;
+//# sourceMappingURL=match.js.map

package/dist/src/server/csmt/memebership-proof.d.ts

@@ -0,0 +1,7 @@
+import { TreeKey, TreeNode } from './types.js';
+export declare enum Direction {
+    Left = "L",
+    Right = "R"
+}
+export type Proof = [TreeKey | null, TreeKey | null] | [TreeKey | Buffer, TreeKey | Direction][];
+export default function membershipProof(root: TreeNode | null, k: TreeKey): Proof;