@based/db 0.0.21 → 0.0.23

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

@@ -5,4 +5,4 @@ export type Search = string[] | {
 } | string;
 export declare const vectorSearch: (def: QueryDef, q: ArrayBufferView, field: string, opts: Omit<FilterOpts, "lowerCase">) => void;
 export declare const search: (def: QueryDef, q: string, s?: Search) => void;
-export declare const searchToBuffer: (search: QueryDefSearch) => Buffer;
+export declare const searchToBuffer: (search: QueryDefSearch) => Uint8Array;

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

@@ -2,7 +2,7 @@ import { langCodesMap } from '@based/schema';
 import { STRING, TEXT, VECTOR } from '@based/schema/def';
 import { getVectorFn } from '../filter/types.js';
 import { searchDoesNotExist, searchIncorrecQueryValue, searchIncorrectType, } from '../validation.js';
-const ENCODER = new TextEncoder();
+import { ENCODER, concatUint8Arr } from '../../../utils.js';
 // vector
 export const vectorSearch = (def, q, field, opts) => {
     let prop = def.props[field];
@@ -24,16 +24,6 @@ export const vectorSearch = (def, q, field, opts) => {
         opts,
     };
 };
-function concatBufs(bufs, totalByteLength) {
-    const res = new Uint8Array(totalByteLength);
-    let off = 0;
-    for (let i = 0; i < bufs.length; i++) {
-        const buf = bufs[i];
-        res.set(buf, off);
-        off += buf.byteLength;
-    }
-    return res;
-}
 export const search = (def, q, s) => {
     const bufs = [];
     let nrBlocks = 0;
@@ -42,7 +32,12 @@ export const search = (def, q, s) => {
         searchIncorrecQueryValue(def, q);
         q = '';
     }
-    const x = q.toLowerCase().normalize('NFKD').trim().split(' ').map((s) => `  ${s}`);
+    const x = q
+        .toLowerCase()
+        .normalize('NFKD')
+        .trim()
+        .split(' ')
+        .map((s) => `  ${s}`);
     for (const s of x) {
         if (s) {
             const buf = ENCODER.encode(s);
@@ -55,7 +50,7 @@ export const search = (def, q, s) => {
         }
     }
     bufs.unshift(Uint8Array.from([nrBlocks]));
-    const query = concatBufs(bufs, totalByteLength);
+    const query = concatUint8Arr(bufs, totalByteLength);
     def.search = {
         size: query.byteLength + 3,
         query,
@@ -104,8 +99,9 @@ export const search = (def, q, s) => {
         if (prop.typeIndex !== STRING && prop.typeIndex !== TEXT) {
             searchIncorrectType(def, prop);
         }
-        def.search.size += 5;
+        def.search.size += 6;
         def.search.fields.push({
+            typeIndex: prop.typeIndex,
             weight: s[key],
             lang,
             field: prop.prop,
@@ -115,10 +111,20 @@ export const search = (def, q, s) => {
 };
 export const searchToBuffer = (search) => {
     if (search.isVector) {
-        // [isVec] [q len] [q len] [field] [fn] [score] [score] [score] [score] [q..]
-        const result = Buffer.allocUnsafe(search.size);
+        /* Vector Binary Schema:
+        | Offset | Field    | Size (bytes) | Description                                     |
+        |--------|----------|--------------|-------------------------------------------------|
+        | 0      | isVector | 1            | Indicates if search is a vector (always 1)      |
+        | 1      | queryLen | 2            | Length of the query in bytes (u16)              |
+        | 3      | field    | 1            | Field identifier                                |
+        | 4      | func     | 1            | Function identifier (enum)                      |
+        | 5      | score    | 4            | Score value (f32)                               |
+        | 9      | query    | queryLen     | Query data (array of f32 values)                |
+        */
+        const result = new Uint8Array(search.size);
         result[0] = 1; // search.isVector 1
-        result.writeUint16LE(search.query.byteLength, 1);
+        result[1] = search.query.byteLength;
+        result[2] = search.query.byteLength >>> 8;
         result[3] = search.prop;
         result[4] = getVectorFn(search.opts.fn);
         result.set(new Uint8Array(new Float32Array([search.opts.score ?? 0.5]).buffer), 5);
@@ -126,9 +132,33 @@ export const searchToBuffer = (search) => {
         return result;
     }
     else {
-        const result = Buffer.allocUnsafe(search.size);
+        /* Non-Vector Search Binary Schema:
+    
+        | Offset | Field    | Size (bytes) | Description                                |
+        |--------|----------|--------------|--------------------------------------------|
+        | 0      | isVector | 1            | Indicates if search is a vector (always 0) |
+        | 1      | queryLen | 2            | Length of the query in bytes (u16)         |
+        | 3      | query    | queryLen     | Query data                                 |
+        | X      | fields   | Variable     | Sorted fields metadata                     |
+    
+        ### Fields Metadata Structure:
+        Each field entry consists of 6 bytes:
+    
+        | Offset | Field     | Size (bytes)| Description                          |
+        |--------|-----------|-------------|--------------------------------------|
+        | 0      | field     | 1           | Field identifier                     |
+        | 1      | typeIndex | 1           | Type index of the field              |
+        | 2      | weight    | 1           | Field weight value                   |
+        | 3      | start     | 2           | Start position in the query (u16)    |
+        | 5      | lang      | 1           | Language identifier                  |
+    
+        ### Notes:
+        - The number of field entries is inferred from the total packet size.
+        - `fields` are sorted by `weight` before being stored in the buffer.*/
+        const result = new Uint8Array(search.size);
         result[0] = 0; // search.isVector 0
-        result.writeUint16LE(search.query.byteLength, 1);
+        result[1] = search.query.byteLength;
+        result[2] = search.query.byteLength >>> 8;
         result.set(search.query, 3);
         const offset = search.query.byteLength + 3;
         // @ts-ignore
@@ -136,13 +166,15 @@ export const searchToBuffer = (search) => {
             return a.weight - b.weight;
         });
         // @ts-ignore
-        for (let i = 0; i < search.fields.length * 5; i += 5) {
+        for (let i = 0; i < search.fields.length * 6; i += 6) {
             // @ts-ignore
-            const f = search.fields[i / 5];
+            const f = search.fields[Math.floor(i / 6)];
             result[i + offset] = f.field;
-            result[i + 1 + offset] = f.weight;
-            result.writeUInt16LE(f.start, i + 2 + offset);
-            result[i + 4 + offset] = f.lang;
+            result[i + offset + 1] = f.typeIndex;
+            result[i + offset + 2] = f.weight;
+            result[i + offset + 3] = f.start;
+            result[i + offset + 4] = f.start >>> 8;
+            result[i + offset + 5] = f.lang;
         }
         return result;
     }

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

@@ -95,7 +95,8 @@ const getFilterFields = (filter, results = {
         conditions.forEach((v, k) => {
             if (k === 0) {
                 for (const buf of v) {
-                    results.main.add(buf.readUint16LE(4));
+                    const x = buf[4] | buf[5] << 8;
+                    results.main.add(x);
                 }
             }
             else {

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

@@ -1,3 +1,3 @@
 import { QueryDef } from './types.js';
 import { DbClient } from '../index.js';
-export declare function defToBuffer(db: DbClient, def: QueryDef): Buffer[];
+export declare function defToBuffer(db: DbClient, def: QueryDef): Uint8Array[];

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

@@ -3,6 +3,8 @@ import { QueryDefType } from './types.js';
 import { includeToBuffer } from './include/toBuffer.js';
 import { filterToBuffer } from './query.js';
 import { searchToBuffer } from './search/index.js';
+import { createAggFnBuffer } from './aggregationFn.js';
+import { ENCODER } from '../../utils.js';
 const byteSize = (arr) => {
     return arr.reduce((a, b) => {
         return a + b.byteLength;
@@ -48,18 +50,21 @@ export function defToBuffer(db, def) {
         if (def.target.resolvedAlias) {
             // put this somehwere else at some point
             const alias = def.target.resolvedAlias;
-            const s = Buffer.byteLength(alias.value);
+            const aliasStr = ENCODER.encode(alias.value);
+            const aliasLen = aliasStr.byteLength;
             // filter is nice for things like access
-            const buf = Buffer.allocUnsafe(8 + filterSize + s);
+            const buf = new Uint8Array(8 + filterSize + aliasLen);
             buf[0] = 3;
             buf[1] = def.schema.idUint8[0];
             buf[2] = def.schema.idUint8[1];
             buf[3] = alias.def.prop;
-            buf.writeUint16LE(s, 4);
-            buf.write(alias.value, 6);
-            buf.writeUint16LE(filterSize, s + 6);
+            buf[4] = aliasLen;
+            buf[5] = aliasLen >>> 8;
+            buf.set(aliasStr, 6);
+            buf[6 + aliasLen] = filterSize;
+            buf[7 + aliasLen] = filterSize >>> 8;
             if (filterSize) {
-                buf.set(filter, 8 + s);
+                buf.set(filter, 8 + aliasLen);
             }
             result.push(buf);
         }
@@ -67,12 +72,16 @@ export function defToBuffer(db, def) {
             // type 0
             // 0: 4 [id]
             // 0: 2 [filterSize]
-            const buf = Buffer.allocUnsafe(9 + filterSize);
+            const buf = new Uint8Array(9 + filterSize);
             buf[0] = 0;
             buf[1] = def.schema.idUint8[0];
             buf[2] = def.schema.idUint8[1];
-            buf.writeUInt32LE(def.target.id, 3);
-            buf.writeUint16LE(filterSize, 7);
+            buf[3] = def.target.id;
+            buf[4] = def.target.id >>> 8;
+            buf[5] = def.target.id >>> 16;
+            buf[6] = def.target.id >>> 24;
+            buf[7] = filterSize;
+            buf[8] = filterSize >>> 8;
             if (filterSize) {
                 buf.set(filter, 9);
             }
@@ -85,6 +94,8 @@ export function defToBuffer(db, def) {
                 sort = createSortBuffer(def.sort);
                 sortSize = sort.byteLength;
             }
+            let aggregation;
+            aggregation = createAggFnBuffer(def.aggregation);
             if (def.target.ids) {
                 // type 1
                 // 1: 4 + ids * 4 [ids len] [id,id,id]
@@ -98,23 +109,35 @@ export function defToBuffer(db, def) {
                     def.target.ids = def.target.ids.slice(def.range.offset, def.range.offset + def.range.limit);
                 }
                 const idsSize = def.target.ids.length * 4;
-                const buf = Buffer.allocUnsafe(21 + idsSize + filterSize + sortSize + searchSize);
+                const buf = new Uint8Array(21 + idsSize + filterSize + sortSize + searchSize);
                 buf[0] = 1;
                 buf[1] = def.schema.idUint8[0];
                 buf[2] = def.schema.idUint8[1];
-                buf.writeUint32LE(idsSize, 3);
+                buf[3] = idsSize;
+                buf[4] = idsSize >>> 8;
+                buf[5] = idsSize >>> 16;
+                buf[6] = idsSize >>> 24;
                 buf.set(new Uint8Array(def.target.ids.buffer), 7);
-                buf.writeUint32LE(def.range.offset, idsSize + 7);
-                buf.writeUint32LE(def.range.limit, idsSize + 11);
-                buf.writeUint16LE(filterSize, idsSize + 15);
+                buf[idsSize + 7] = def.range.offset;
+                buf[idsSize + 8] = def.range.offset >>> 8;
+                buf[idsSize + 9] = def.range.offset >>> 16;
+                buf[idsSize + 10] = def.range.offset >>> 24;
+                buf[idsSize + 11] = def.range.limit;
+                buf[idsSize + 12] = def.range.limit >>> 8;
+                buf[idsSize + 13] = def.range.limit >>> 16;
+                buf[idsSize + 14] = def.range.limit >>> 24;
+                buf[idsSize + 15] = filterSize;
+                buf[idsSize + 16] = filterSize >>> 8;
                 if (filterSize) {
                     buf.set(filter, idsSize + 17);
                 }
-                buf.writeUint16LE(sortSize, 17 + filterSize + idsSize);
+                buf[17 + filterSize + idsSize] = sortSize;
+                buf[18 + filterSize + idsSize] = sortSize >>> 8;
                 if (sortSize) {
                     buf.set(sort, 19 + filterSize + idsSize);
                 }
-                buf.writeUint16LE(searchSize, 19 + filterSize + idsSize + sortSize);
+                buf[19 + filterSize + idsSize + sortSize] = searchSize;
+                buf[20 + filterSize + idsSize + sortSize] = searchSize >>> 8;
                 if (searchSize) {
                     buf.set(search, 21 + filterSize + idsSize + sortSize);
                 }
@@ -129,24 +152,36 @@ export function defToBuffer(db, def) {
                 // ?filter
                 // 2: 2 [sort size]
                 // ?sort
-                const buf = Buffer.allocUnsafe(17 + filterSize + sortSize + searchSize);
+                const buf = new Uint8Array(18 + filterSize + sortSize + searchSize);
                 buf[0] = 2;
                 buf[1] = def.schema.idUint8[0];
                 buf[2] = def.schema.idUint8[1];
-                buf.writeUint32LE(def.range.offset, 3);
-                buf.writeUint32LE(def.range.limit, 7);
-                buf.writeUint16LE(filterSize, 11);
+                buf[3] = def.range.offset;
+                buf[4] = def.range.offset >>> 8;
+                buf[5] = def.range.offset >>> 16;
+                buf[6] = def.range.offset >>> 24;
+                buf[7] = def.range.limit;
+                buf[8] = def.range.limit >>> 8;
+                buf[9] = def.range.limit >>> 16;
+                buf[10] = def.range.limit >>> 24;
+                buf[11] = filterSize;
+                buf[12] = filterSize >>> 8;
                 if (filterSize) {
                     buf.set(filter, 13);
                 }
-                buf.writeUint16LE(sortSize, 13 + filterSize);
+                buf[13 + filterSize] = sortSize;
+                buf[14 + filterSize] = sortSize >>> 8;
                 if (sortSize) {
                     buf.set(sort, 15 + filterSize);
                 }
-                buf.writeUint16LE(searchSize, 15 + filterSize + sortSize);
+                buf[15 + filterSize + sortSize] = searchSize;
+                buf[16 + filterSize + sortSize] = searchSize >>> 8;
                 if (searchSize) {
                     buf.set(search, 17 + filterSize + sortSize);
                 }
+                if (aggregation) {
+                    buf.set(aggregation, 17 + filterSize + sortSize + searchSize);
+                }
                 result.push(buf);
             }
         }
@@ -166,13 +201,23 @@ export function defToBuffer(db, def) {
         const sortSize = sort?.byteLength ?? 0;
         const filterSize = filter?.byteLength ?? 0;
         const modsSize = filterSize + sortSize;
-        const meta = Buffer.allocUnsafe(modsSize + 10 + 8);
+        const meta = new Uint8Array(modsSize + 10 + 8);
+        const sz = size + 7 + modsSize + 8;
         meta[0] = 254;
-        meta.writeUint16LE(size + 7 + modsSize + 8, 1);
-        meta.writeUint16LE(filterSize, 3);
-        meta.writeUint16LE(sortSize, 5);
-        meta.writeUint32LE(def.range.offset, 7);
-        meta.writeUint32LE(def.range.limit, 7 + 4);
+        meta[1] = sz;
+        meta[2] = sz >>> 8;
+        meta[3] = filterSize;
+        meta[4] = filterSize >>> 8;
+        meta[5] = sortSize;
+        meta[6] = sortSize >>> 8;
+        meta[7] = def.range.offset;
+        meta[8] = def.range.offset >>> 8;
+        meta[9] = def.range.offset >>> 16;
+        meta[10] = def.range.offset >>> 24;
+        meta[11] = def.range.limit;
+        meta[12] = def.range.limit >>> 8;
+        meta[13] = def.range.limit >>> 16;
+        meta[14] = def.range.limit >>> 24;
         if (filter) {
             meta.set(filter, 15);
         }
@@ -185,9 +230,11 @@ export function defToBuffer(db, def) {
         result.push(meta);
     }
     else if (def.type === QueryDefType.Reference) {
-        const meta = Buffer.allocUnsafe(6);
+        const meta = new Uint8Array(6);
+        const sz = size + 3;
         meta[0] = 255;
-        meta.writeUint16LE(size + 3, 1);
+        meta[1] = sz;
+        meta[2] = sz >>> 8;
         meta[3] = def.schema.idUint8[0];
         meta[4] = def.schema.idUint8[1];
         meta[5] = def.target.propDef.prop;
@@ -195,9 +242,10 @@ export function defToBuffer(db, def) {
     }
     result.push(...include);
     if (edges) {
-        const metaEdgeBuffer = Buffer.allocUnsafe(3);
+        const metaEdgeBuffer = new Uint8Array(3);
         metaEdgeBuffer[0] = 252;
-        metaEdgeBuffer.writeUint16LE(edgesSize, 1);
+        metaEdgeBuffer[1] = edgesSize;
+        metaEdgeBuffer[2] = edgesSize >>> 8;
         result.push(metaEdgeBuffer, ...edges);
     }
     return result;

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

@@ -29,7 +29,7 @@ export type Target = {
 export declare const isRefDef: (def: QueryDef) => def is QueryDefRest;
 export type QueryDefFilter = {
     size: number;
-    conditions: Map<number, Buffer[]>;
+    conditions: Map<number, Uint8Array[]>;
     exists?: {
         prop: PropDef | PropDefEdge;
         negate: boolean;
@@ -37,7 +37,7 @@ export type QueryDefFilter = {
     references?: Map<number, QueryDefFilter>;
     fromRef?: PropDef;
     schema?: SchemaTypeDef;
-    edges?: Map<number, Buffer[]>;
+    edges?: Map<number, Uint8Array[]>;
     or?: QueryDefFilter;
     and?: QueryDefFilter;
 };
@@ -50,6 +50,7 @@ export type QueryDefSearch = {
         field: number;
         start: number;
         lang: LangCode;
+        typeIndex: number;
     }[];
 } | {
     size: number;
@@ -69,7 +70,6 @@ export type QueryDefShared = {
     filter: QueryDefFilter;
     search: null | QueryDefSearch;
     sort: null | QueryDefSort;
-    reverseProps: any;
     skipValidation: boolean;
     range: {
         offset: number;
@@ -92,6 +92,7 @@ export type QueryDefShared = {
     };
     references: Map<number, QueryDef>;
     edges?: QueryDef;
+    aggregation: AggFn;
 };
 export type QueryDefEdges = {
     type: QueryDefType.Edge;
@@ -113,3 +114,24 @@ export type QueryByAliasObj = {
     [key: string]: string | QueryByAliasObj;
 };
 export declare const isAlias: (id: QueryByAliasObj | number | Uint32Array | (QueryByAliasObj | number)[]) => id is QueryByAliasObj;
+export declare const READ_ID = 255;
+export declare const READ_EDGE = 252;
+export declare const READ_REFERENCES = 253;
+export declare const READ_REFERENCE = 254;
+export declare const CREATE_AGGREGATION = 250;
+export declare const READ_AGGREGATION = 251;
+export declare const enum AggFn {
+    AVG = 1,
+    CARDINALITY = 2,
+    CONCAT = 3,// string aggregation, delimiter should be an argument
+    COUNT = 4,
+    MAX = 5,
+    MIN = 6,
+    MODE = 7,// ordered-set
+    PERCENTILE = 8,// continuous or discrete should be optional parameters, default = discrete
+    RANK = 9,// hypothetical-set, dense should be optional parameter
+    STDDEV = 10,// population or sample should be optional parameters, default = sample
+    SUM = 11,
+    VARIANCE = 12,
+    NONE = -999
+}

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

@@ -18,4 +18,10 @@ export const isAlias = (id) => {
         !Array.isArray(id) &&
         !ArrayBuffer.isView(id));
 };
+export const READ_ID = 255;
+export const READ_EDGE = 252;
+export const READ_REFERENCES = 253;
+export const READ_REFERENCE = 254;
+export const CREATE_AGGREGATION = 250;
+export const READ_AGGREGATION = 251;
 //# sourceMappingURL=types.js.map

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

@@ -93,7 +93,7 @@ export const isValidId = (id) => {
 };
 export const isValidString = (v) => {
     const isVal = typeof v === 'string' ||
-        v instanceof Buffer ||
+        v instanceof Uint8Array ||
         ArrayBuffer.isView(v);
     return isVal;
 };

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

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

package/dist/src/client/string.js

@@ -1,8 +1,7 @@
 import native from '../native.js';
 import { readUint32 } from './bitWise.js';
 import makeTmpBuffer from './tmpBuffer.js';
-const DECODER = new TextDecoder('utf-8');
-const ENCODER = new TextEncoder();
+import { DECODER, ENCODER } from '../utils.js';
 const { getUint8Array: getTmpBuffer } = makeTmpBuffer(4096); // the usual page size?
 // type 0 = no compression; 1 = deflate
 // [lang] [type] [uncompressed size 4] [compressed string] [crc32]

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

@@ -1 +1 @@
-export declare const xxHash64: (buf: Buffer | Uint8Array, target?: Uint8Array | Buffer, index?: number) => Uint8Array | Buffer;
+export declare const xxHash64: (buf: Uint8Array, target?: Uint8Array, index?: number) => Uint8Array;

package/dist/src/index.d.ts

@@ -1,5 +1,5 @@
 import { compress, decompress } from './client/string.js';
-import { ModifyCtx } from './client/operations.js';
+import { ModifyCtx } from './client/flushModify.js';
 import { DbServer } from './server/index.js';
 import { DbClient } from './client/index.js';
 export * from './client/modify/modify.js';
@@ -27,14 +27,15 @@ export declare class BasedDb {
     upsert: DbClient['upsert'];
     delete: DbClient['delete'];
     expire: DbClient['expire'];
-    remove: DbClient['delete'];
     query: DbClient['query'];
-    putSchema: DbClient['putSchema'];
+    setSchema: DbClient['setSchema'];
+    putSchema: DbClient['setSchema'];
     drain: DbClient['drain'];
     start: DbServer['start'];
     stop: DbServer['stop'];
     save: DbServer['save'];
     migrateSchema: DbServer['migrateSchema'];
+    isReady: DbClient['isModified'];
     destroy(): Promise<void>;
     wipe(): Promise<void>;
 }

package/dist/src/index.js

@@ -1,8 +1,9 @@
 import { compress, decompress } from './client/string.js';
-import { ModifyCtx } from './client/operations.js';
+import { ModifyCtx } from './client/flushModify.js';
 import { DbServer } from './server/index.js';
 import { DbClient } from './client/index.js';
 import picocolors from 'picocolors';
+import { wait } from '@saulx/utils';
 export * from './client/modify/modify.js';
 export { compress, decompress };
 export { ModifyCtx }; // TODO move this somewhere
@@ -45,8 +46,9 @@ export class BasedDb {
         const client = new DbClient({
             maxModifySize,
             hooks: {
-                putSchema(schema, fromStart) {
-                    return Promise.resolve(server.putSchema(schema, fromStart));
+                flushTime: 0,
+                setSchema(schema, fromStart) {
+                    return Promise.resolve(server.setSchema(schema, fromStart));
                 },
                 flushModify(buf) {
                     const offsets = server.modify(buf);
@@ -54,6 +56,8 @@ export class BasedDb {
                         offsets,
                     });
                 },
+                flushReady: () => { },
+                flushIsReady: new Promise(() => { }),
                 getQueryBuf(buf) {
                     return Promise.resolve(server.getQueryBuf(buf));
                 },
@@ -81,15 +85,15 @@ export class BasedDb {
     expire = function () {
         return this.client.expire.apply(this.client, arguments);
     };
-    remove = function () {
-        console.warn('WARNING: db.remove() is deprecated. Use db.delete() instead');
-        return this.client.delete.apply(this.client, arguments);
-    };
     query = function () {
         return this.client.query.apply(this.client, arguments);
     };
+    setSchema = function () {
+        return this.client.setSchema.apply(this.client, arguments);
+    };
     putSchema = function () {
-        return this.client.putSchema.apply(this.client, arguments);
+        console.warn('URGENT: putSchema will be removed in next release. Use setSchema instead!');
+        return this.setSchema.apply(this, arguments);
     };
     drain = function () {
         return this.client.drain.apply(this.client, arguments);
@@ -108,10 +112,15 @@ export class BasedDb {
     migrateSchema = function () {
         return this.server.migrateSchema.apply(this.server, arguments);
     };
-    // both
-    destroy() {
+    isReady = function () {
+        return this.client.isReady.apply(this.client, arguments);
+    };
+    async destroy() {
+        // Tmp fix: Gives node time to GC existing buffers else it can incorrectly re-asign to mem
+        // Todo: clear all active queries, queues ETC
+        await wait(Math.max(this.client.hooks.flushTime + 10, 10));
         this.client.destroy();
-        return this.server.destroy();
+        await this.server.destroy();
     }
     async wipe() {
         const opts = {

package/dist/src/native.d.ts

@@ -4,8 +4,8 @@ declare const _default: {
     workerCtxInit: () => void;
     externalFromInt(address: BigInt): any;
     intFromExternal(external: any): BigInt;
-    modify: (data: Buffer, types: Buffer, dbCtx: any) => any;
-    getQueryBuf: (q: Buffer, dbCtx: any) => ArrayBuffer | null;
+    modify: (data: Uint8Array, types: Uint8Array, dbCtx: any) => any;
+    getQueryBuf: (q: Uint8Array, dbCtx: any) => ArrayBuffer | null;
     start: (id: number) => any;
     stop: (dbCtx: any) => any;
     saveCommon: (path: string, dbCtx: any) => number;
@@ -15,17 +15,12 @@ declare const _default: {
     updateSchemaType: (prefix: number, buf: Uint8Array, dbCtx: any) => any;
     getTypeInfo: (typeId: number, dbCtx: any) => any;
     getNodeRangeHash: (typeId: number, start: number, end: number, bufOut: Uint8Array, dbCtx: any) => any;
-    createHash: () => {
-        update: (buf: Buffer | Uint8Array) => any;
-        digest: (encoding?: "hex") => Uint8Array | string;
-        reset: () => void;
-    };
-    compress: (buf: Buffer | Uint8Array, offset: number, stringSize: number) => any;
-    decompress: (input: Buffer | Uint8Array, output: Buffer | Uint8Array, offset: number, len: number) => any;
-    crc32: (buf: Buffer | Uint8Array) => any;
-    createSortIndex: (buf: Buffer, dbCtx: any) => any;
-    destroySortIndex: (buf: Buffer, dbCtx: any) => any;
-    xxHash64: (buf: Buffer | Uint8Array, target: Buffer | Uint8Array, index: number) => any;
+    compress: (buf: Uint8Array, offset: number, stringSize: number) => any;
+    decompress: (input: Uint8Array, output: Uint8Array, offset: number, len: number) => any;
+    crc32: (buf: Uint8Array) => any;
+    createSortIndex: (buf: Uint8Array, dbCtx: any) => any;
+    destroySortIndex: (buf: Uint8Array, dbCtx: any) => any;
+    xxHash64: (buf: Uint8Array, target: Uint8Array, index: number) => any;
     base64encode: (dst: Uint8Array, src: Uint8Array, lineMax: number) => Uint8Array;
     equals: (a: Uint8Array, b: Uint8Array) => boolean;
 };