@based/db 0.0.19 → 0.0.21

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

@@ -2,4 +2,4 @@ import { LangCode } from '@based/schema';
 import { ModifyCtx } from '../../index.js';
 import { SchemaTypeDef, PropDef } from '@based/schema/def';
 import { ModifyOp, ModifyErr } from './types.js';
-export declare function writeString(lang: LangCode, value: string | null | Buffer, ctx: ModifyCtx, def: SchemaTypeDef, t: PropDef, parentId: number, modifyOp: ModifyOp): ModifyErr;
+export declare function writeString(lang: LangCode, value: string | null | Uint8Array, ctx: ModifyCtx, def: SchemaTypeDef, t: PropDef, parentId: number, modifyOp: ModifyOp): ModifyErr;

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

@@ -6,14 +6,14 @@ import { write } from '../string.js';
 // add compression handling for main buffer
 // add compression handling for edge fields
 export function writeString(lang, value, ctx, def, t, parentId, modifyOp) {
-    const isBuffer = value instanceof Buffer;
+    const isBuffer = value instanceof Uint8Array;
     if (typeof value !== 'string' && value !== null && !isBuffer) {
         return new ModifyError(t, value);
     }
     const len = value?.length;
     if (!len) {
         if (modifyOp === UPDATE) {
-            if (ctx.len + 11 > ctx.max) {
+            if (ctx.len + 11 /* SIZE.DEFAULT_CURSOR */ + 1 > ctx.max) {
                 return RANGE_ERR;
             }
             setCursor(ctx, def, t.prop, t.typeIndex, parentId, modifyOp);
@@ -24,7 +24,9 @@ export function writeString(lang, value, ctx, def, t, parentId, modifyOp) {
         let size = isBuffer
             ? value.byteLength
             : Buffer.byteLength(value, 'utf8') + 6;
-        if (ctx.len + 20 + size > ctx.max) {
+        if (ctx.len + 11 /* SIZE.DEFAULT_CURSOR */ + 11 + size > ctx.max) {
+            // +10 OR +11, teh original check was +20 but
+            // there are 10 addtional bytes in this scope
             // 5 compression size
             return RANGE_ERR;
         }

package/dist/src/client/modify/text.d.ts

@@ -5,4 +5,4 @@ import { writeString } from './string.js';
 import { ModifyState } from './ModifyRes.js';
 export declare function writeText(value: {
     [k: string]: Parameters<typeof writeString>[1];
-}, ctx: ModifyCtx, def: SchemaTypeDef, t: PropDef, res: ModifyState, modifyOp: ModifyOp): ModifyErr;
+} | Parameters<typeof writeString>[1], ctx: ModifyCtx, def: SchemaTypeDef, t: PropDef, res: ModifyState, parentId: number, modifyOp: ModifyOp): ModifyErr;

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

@@ -1,24 +1,67 @@
 import { langCodesMap } from '@based/schema';
-import { CREATE } from './types.js';
+import { CREATE, UPDATE, RANGE_ERR, DELETE, } from './types.js';
 import { writeString } from './string.js';
-export function writeText(value, ctx, def, t, res, modifyOp) {
+import { ModifyError } from './ModifyRes.js';
+import { setCursor } from './setCursor.js';
+export function writeText(value, ctx, def, t, res, parentId, modifyOp) {
+    const isBuffer = value instanceof Uint8Array;
+    if (typeof value !== 'string' &&
+        value !== null &&
+        !isBuffer &&
+        value &&
+        typeof value !== 'object') {
+        return new ModifyError(t, value);
+    }
+    // const len = value?.length
+    // think about this
+    if (value === null && !res.locale) {
+        if (modifyOp === UPDATE) {
+            if (ctx.len + 11 /* SIZE.DEFAULT_CURSOR */ + 1 > ctx.max) {
+                return RANGE_ERR;
+            }
+            setCursor(ctx, def, t.prop, t.typeIndex, parentId, modifyOp);
+            ctx.buf[ctx.len++] = DELETE;
+        }
+        return;
+    }
     // todo proper fallback as well
-    if (value && typeof value !== 'object') {
-        const err = writeString(res.locale ?? langCodesMap.get('en'), value, ctx, def, t, res.tmpId, modifyOp);
+    if ((value && typeof value !== 'object') || value === null) {
+        const locale = res.locale ?? langCodesMap.get('en'); // TODO: Add def lang option...
+        if (value == null) {
+            // @ts-ignore
+            value = '';
+        }
+        // @ts-ignore
+        const err = writeString(res.locale, value, ctx, def, t, res.tmpId, modifyOp);
         if (modifyOp === CREATE) {
-            def.seperateTextSort.bufferTmp[t.prop * def.localeSize] = 2;
-            ctx.hasSortText++;
+            const index = t.prop * (def.localeSize + 1);
+            const langIndex = def.seperateTextSort.localeToIndex.get(locale);
+            def.seperateTextSort.bufferTmp[index] -= 1;
+            def.seperateTextSort.bufferTmp[index + langIndex] = 0;
+            ctx.hasSortText += 1;
         }
         return err;
     }
     else {
+        // @ts-ignore
         for (const lang in value) {
-            const langCode = langCodesMap.get(lang) || langCodesMap.get('en'); // TODO use proper fallback
-            const s = value[lang];
-            const err = writeString(langCode, s, ctx, def, t, res.tmpId, modifyOp);
+            const langC = def.seperateTextSort.localeStringToIndex.get(lang);
+            if (!langC) {
+                return new ModifyError(t, lang, 'Invalid locale');
+            }
+            let s = value[lang];
+            if (s == null) {
+                // @ts-ignore
+                s = '';
+            }
+            const err = writeString(langC[1], s, ctx, def, t, res.tmpId, modifyOp);
             if (err) {
                 return err;
             }
+            const index = t.prop * (1 + def.localeSize);
+            def.seperateTextSort.bufferTmp[index] -= 1;
+            def.seperateTextSort.bufferTmp[index + langC[0]] = 0;
+            ctx.hasSortText += 1;
         }
     }
 }

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

@@ -3,7 +3,8 @@ import { ModifyError } from './ModifyRes.js';
 export declare const CREATE = 3;
 export declare const UPDATE = 6;
 export declare const DELETE = 11;
-export declare const MERGE_MAIN = 4;
+export declare const DELETE_SORT_INDEX = 4;
+export declare const DELETE_NODE = 10;
 export declare const RANGE_ERR = 1;
 export declare const INCREMENT = 12;
 export declare const DECREMENT = 13;
@@ -14,6 +15,9 @@ export declare const SWITCH_TYPE = 2;
 export declare const SWITCH_FIELD = 0;
 export declare const SWITCH_ID_CREATE = 9;
 export declare const SWITCH_ID_UPDATE = 1;
+export declare const enum SIZE {
+    DEFAULT_CURSOR = 11
+}
 export type ModifyErr = typeof RANGE_ERR | ModifyError | void;
 export type ModifyOp = typeof CREATE | typeof UPDATE | typeof INCREMENT | typeof EXPIRE;
 export type ModifyOpts = {

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

@@ -1,7 +1,8 @@
 export const CREATE = 3;
 export const UPDATE = 6;
 export const DELETE = 11;
-export const MERGE_MAIN = 4;
+export const DELETE_SORT_INDEX = 4;
+export const DELETE_NODE = 10;
 export const RANGE_ERR = 1;
 export const INCREMENT = 12;
 export const DECREMENT = 13;

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

@@ -1,4 +1,4 @@
-import { UPDATE, RANGE_ERR, DELETE } from './types.js';
+import { UPDATE, RANGE_ERR, DELETE, } from './types.js';
 import { ModifyError } from './ModifyRes.js';
 import { setCursor } from './setCursor.js';
 function write(value, ctx, fieldSize) {
@@ -9,7 +9,7 @@ function write(value, ctx, fieldSize) {
     ctx.buf[ctx.len++] = tmp >>>= 8;
     ctx.buf[ctx.len++] = tmp >>>= 8;
     ctx.buf[ctx.len++] = tmp >>>= 8;
-    Buffer.from(value.buffer).copy(ctx.buf, ctx.len, 0, size);
+    ctx.buf.set(new Uint8Array(value.buffer).subarray(0, size), ctx.len);
     ctx.len += size;
 }
 export function writeVector(value, ctx, schema, t, parentId, modifyOp) {
@@ -25,7 +25,7 @@ export function writeVector(value, ctx, schema, t, parentId, modifyOp) {
     }
     if (size === 0) {
         if (modifyOp === UPDATE) {
-            if (ctx.len + 11 > ctx.max) {
+            if (ctx.len + 11 /* SIZE.DEFAULT_CURSOR */ + 1 > ctx.max) {
                 // TODO ???
                 return RANGE_ERR;
             }
@@ -34,7 +34,7 @@ export function writeVector(value, ctx, schema, t, parentId, modifyOp) {
         }
     }
     else {
-        if (ctx.len + 15 + size > ctx.max) {
+        if (ctx.len + 11 /* SIZE.DEFAULT_CURSOR */ + 5 + size > ctx.max) {
             // TODO ???
             return RANGE_ERR;
         }

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

@@ -15,7 +15,9 @@ export const convertFilter = (def, field, operator, value, opts) => {
         value = operator;
         operator = '=';
     }
-    if (value === '' || value === undefined) {
+    if (!(operator === 'exists' || operator === '!exists') &&
+        (value === '' || value === undefined)) {
+        // not great...
         return;
     }
     if (operator === '!..') {

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

@@ -20,7 +20,7 @@ export const writeFixed = (prop, buf, value, size, offset) => {
             const size = buf.write(value, offset + 1, 'utf8');
             buf[offset] = size;
         }
-        else if (value instanceof Buffer) {
+        else if (value instanceof Uint8Array) {
             buf.set(value, offset);
         }
         else {

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

@@ -2,7 +2,7 @@ import { ALIAS, TEXT, VECTOR } from '@based/schema/def';
 import { EQUAL, EQUAL_CRC32, HAS, HAS_TO_LOWER_CASE, LIKE, MODE_DEFAULT_VAR, MODE_OR_VAR, getVectorFn, } from './types.js';
 import { createFixedFilterBuffer } from './createFixedFilterBuffer.js';
 import { crc32 } from '../../crc32.js';
-const DEFAULT_SCORE = Buffer.from(new Float32Array([0.5]).buffer);
+const DEFAULT_SCORE = new Uint8Array(new Float32Array([0.5]).buffer);
 const parseValue = (value, prop, ctx, lang) => {
     let val = value;
     if (ctx.operation === HAS_TO_LOWER_CASE && typeof val === 'string') {
@@ -12,11 +12,17 @@ const parseValue = (value, prop, ctx, lang) => {
         if (!(val instanceof ArrayBuffer)) {
             throw new Error('Vector should be an arrayBuffer');
         }
-        let fn = getVectorFn(ctx.opts.fn);
+        const vector = new Uint8Array(val);
+        let fn = new Uint8Array([getVectorFn(ctx.opts.fn)]);
         const score = ctx.opts.score
-            ? Buffer.from(new Float32Array([ctx.opts.score]).buffer)
+            ? new Uint8Array(new Float32Array([ctx.opts.score]).buffer)
             : DEFAULT_SCORE;
-        val = Buffer.concat([Buffer.from(val), Buffer.from([fn]), score]);
+        const buf = new Uint8Array(vector.byteLength + fn.byteLength + score.byteLength);
+        let off = 0;
+        off += (buf.set(new Uint8Array(vector), off), vector.byteLength);
+        off += (buf.set(fn, off), fn.byteLength);
+        buf.set(score, off);
+        val = buf;
     }
     if (val instanceof Uint8Array ||
         typeof value === 'string' ||

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

@@ -1,6 +1,7 @@
 import { TIMESTAMP, CREATED, UPDATED, ENUM, BOOLEAN, STRING, BINARY, TEXT, } from '@based/schema/def';
 import { crc32 } from '../../crc32.js';
 import { convertToTimestamp } from '../../timestamp.js';
+const ENCODER = new TextEncoder();
 // -------------------------------------------
 // conditions normal
 // field, [size 2]
@@ -18,10 +19,18 @@ export const parseFilterValue = (prop, value) => {
     if (prop.typeIndex === BINARY ||
         prop.typeIndex === STRING ||
         prop.typeIndex === TEXT) {
-        const b = value instanceof Buffer ? value : Buffer.from(value);
-        const buf = Buffer.allocUnsafe(8);
-        buf.writeUint32LE(crc32(b), 0);
-        buf.writeUint32LE(b.byteLength, 4);
+        const b = value instanceof Uint8Array ? value : ENCODER.encode(value);
+        const buf = new Uint8Array(8);
+        let crc = crc32(b);
+        buf[0] = crc;
+        buf[1] = crc >>>= 8;
+        buf[2] = crc >>>= 8;
+        buf[3] = crc >>>= 8;
+        let len = b.byteLength;
+        buf[4] = len;
+        buf[5] = len >>>= 8;
+        buf[6] = len >>>= 8;
+        buf[7] = len >>>= 8;
         return buf;
     }
     else if (prop.typeIndex === BOOLEAN) {

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

@@ -1,5 +1,5 @@
 import { CARDINALITY, REFERENCE, REFERENCES, REVERSE_SIZE_MAP, } from '@based/schema/def';
-import { EQUAL, isNumerical } from './types.js';
+import { EQUAL, EXISTS, isNumerical, TYPE_NEGATE } from './types.js';
 import { createVariableFilterBuffer } from './createVariableFilterBuffer.js';
 import { createFixedFilterBuffer } from './createFixedFilterBuffer.js';
 import { createReferenceFilter } from './createReferenceFilter.js';
@@ -9,10 +9,20 @@ export const primitiveFilter = (def, prop, filter, conditions, lang) => {
         return;
     }
     let [, ctx, value] = filter;
-    const fieldIndexChar = prop.prop;
     let buf;
-    let size = 0;
+    const fieldIndexChar = prop.prop;
     const bufferMap = prop.__isEdge ? conditions.edges : conditions.conditions;
+    if (ctx.operation === EXISTS) {
+        if (!conditions.exists) {
+            conditions.exists = [];
+        }
+        conditions.exists.push({
+            prop: prop,
+            negate: filter[1].type === TYPE_NEGATE,
+        });
+        return 4;
+    }
+    let size = 0;
     const isArray = Array.isArray(value);
     if (isArray && value.length === 1) {
         value = value[0];

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

@@ -1,4 +1,4 @@
-import { META_EDGE, META_OR_BRANCH, META_REFERENCE } from './types.js';
+import { META_EDGE, META_EXISTS, META_OR_BRANCH, META_REFERENCE, TYPE_DEFAULT, TYPE_NEGATE, } from './types.js';
 // or
 // [meta = 253]  [size 2] [next 4]
 // -------------------------------------------
@@ -17,7 +17,6 @@ import { META_EDGE, META_OR_BRANCH, META_REFERENCE } from './types.js';
 const writeConditions = (result, k, offset, conditions) => {
     let lastWritten = offset;
     result[lastWritten] = k;
-    // result[lasWritten + 1] = typeIndex
     lastWritten++;
     const sizeIndex = lastWritten;
     lastWritten += 2;
@@ -27,7 +26,6 @@ const writeConditions = (result, k, offset, conditions) => {
         result.set(condition, lastWritten);
         lastWritten += condition.byteLength;
     }
-    // make this u32
     result.writeUint16LE(conditionSize, sizeIndex);
     return lastWritten - offset;
 };
@@ -76,6 +74,18 @@ export const fillConditionsBuffer = (result, conditions, offset) => {
         result.writeUint32LE(lastWritten, orJumpIndex + 2);
         lastWritten += size;
     }
+    if (conditions.exists) {
+        for (const exists of conditions.exists) {
+            result[lastWritten] = META_EXISTS;
+            lastWritten++;
+            result[lastWritten] = exists.prop.prop;
+            lastWritten++;
+            result[lastWritten] = exists.negate ? TYPE_NEGATE : TYPE_DEFAULT;
+            lastWritten++;
+            result[lastWritten] = exists.prop.typeIndex;
+            lastWritten++;
+        }
+    }
     return lastWritten - offset;
 };
 // TODO convert to UINT8ARRAY

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

@@ -4,7 +4,7 @@ export type Filter = [fieldStr: string, ctx: FilterCtx, value: any];
 export type FilterBranchFn = (filterBranch: FilterBranch) => void;
 export type FilterAst = (Filter | FilterAst)[];
 export declare const IsFilter: (f: FilterAst) => f is Filter;
-export type Operator = '=' | 'has' | '!has' | '<' | '>' | '!=' | 'like' | '>=' | '<=' | '..' | '!..' | 'like';
+export type Operator = '=' | 'has' | '!has' | '<' | '>' | '!=' | 'like' | '>=' | '<=' | '..' | '!..' | 'like' | 'exists' | '!exists';
 export declare const VECTOR_FNS: string[];
 export type FilterOpts<O = Operator> = {
     lowerCase?: boolean;
@@ -27,7 +27,8 @@ export declare const HAS_TO_LOWER_CASE = 13;
 export declare const STARTS_WITH_LOWER_CASE = 14;
 export declare const ENDS_WITH_LOWER_CASE = 15;
 export declare const LIKE = 18;
-export type OPERATOR = typeof EQUAL | typeof HAS | typeof ENDS_WITH | typeof STARTS_WITH | typeof GREATER_THAN | typeof SMALLER_THAN | typeof GREATER_THAN_INCLUSIVE | typeof SMALLER_THAN_INCLUSIVE | typeof RANGE | typeof RANGE_EXCLUDE | typeof EQUAL_LOWER_CASE | typeof HAS_TO_LOWER_CASE | typeof STARTS_WITH_LOWER_CASE | typeof ENDS_WITH_LOWER_CASE | typeof LIKE | typeof EQUAL_CRC32;
+export declare const EXISTS = 19;
+export type OPERATOR = typeof EQUAL | typeof HAS | typeof ENDS_WITH | typeof STARTS_WITH | typeof GREATER_THAN | typeof SMALLER_THAN | typeof GREATER_THAN_INCLUSIVE | typeof SMALLER_THAN_INCLUSIVE | typeof RANGE | typeof RANGE_EXCLUDE | typeof EQUAL_LOWER_CASE | typeof HAS_TO_LOWER_CASE | typeof STARTS_WITH_LOWER_CASE | typeof ENDS_WITH_LOWER_CASE | typeof LIKE | typeof EQUAL_CRC32 | typeof EXISTS;
 export declare const isNumerical: (op: OPERATOR) => boolean;
 export declare const TYPE_NEGATE = 1;
 export declare const TYPE_DEFAULT = 2;
@@ -39,10 +40,11 @@ export declare const MODE_AND_FIXED = 3;
 export declare const MODE_DEFAULT_VAR = 4;
 export declare const MODE_REFERENCE = 5;
 export type FILTER_MODE = typeof MODE_DEFAULT | typeof MODE_OR_FIXED | typeof MODE_OR_VAR | typeof MODE_AND_FIXED | typeof MODE_DEFAULT_VAR | typeof MODE_REFERENCE;
+export declare const META_EXISTS = 251;
 export declare const META_EDGE = 252;
 export declare const META_OR_BRANCH = 253;
 export declare const META_REFERENCE = 254;
-export type FILTER_META = typeof META_EDGE | typeof META_OR_BRANCH | typeof META_REFERENCE;
+export type FILTER_META = typeof META_EDGE | typeof META_OR_BRANCH | typeof META_REFERENCE | typeof META_EXISTS;
 export type FilterCtx = {
     operation: OPERATOR;
     type: FILTER_TYPE;

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

@@ -34,6 +34,9 @@ export const STARTS_WITH_LOWER_CASE = 14;
 export const ENDS_WITH_LOWER_CASE = 15;
 export const LIKE = 18;
 // -------------------------------------------
+// only valid for seperate fields
+export const EXISTS = 19;
+// -------------------------------------------
 export const isNumerical = (op) => {
     if (op === GREATER_THAN ||
         op === SMALLER_THAN ||
@@ -59,6 +62,7 @@ export const MODE_DEFAULT_VAR = 4;
 export const MODE_REFERENCE = 5;
 // -------------------------------------------
 // Meta
+export const META_EXISTS = 251;
 export const META_EDGE = 252;
 export const META_OR_BRANCH = 253;
 export const META_REFERENCE = 254;
@@ -88,6 +92,13 @@ export const toFilterCtx = (def, op, opts = {}) => {
             opts,
         };
     }
+    if (op === 'exists' || op === '!exists') {
+        return {
+            operation: EXISTS,
+            type: op === '!exists' ? TYPE_NEGATE : TYPE_DEFAULT,
+            opts,
+        };
+    }
     if (op === 'has' || op === '!has') {
         return {
             operation: opts.lowerCase ? HAS_TO_LOWER_CASE : HAS,
@@ -129,5 +140,6 @@ export const operatorReverseMap = {
     [ENDS_WITH_LOWER_CASE]: 'endsWith (lowerCase)',
     [LIKE]: 'like',
     [EQUAL_CRC32]: '= (crc32)',
+    [EXISTS]: 'exists',
 };
 //# sourceMappingURL=types.js.map

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

@@ -234,6 +234,12 @@ export const readAllFields = (q, result, offset, end, item, id) => {
                     }
                     i += size + 4;
                 }
+                else if (t === CARDINALITY) {
+                    i++;
+                    const size = readUint32(result, i);
+                    addField(edgeDef, readUint32(result, i + 4), item);
+                    i += size + 4;
+                }
                 else {
                     i++;
                     readMainValue(edgeDef, result, i, item);
@@ -290,7 +296,7 @@ export const readAllFields = (q, result, offset, end, item, id) => {
             else if (prop.typeIndex === JSON) {
                 q.include.propsRead[index] = id;
                 const size = readUint32(result, i);
-                addField(prop, global.JSON.parse(Buffer.from(result.subarray(i + 6, i + size)).toString()), item);
+                addField(prop, global.JSON.parse(readUtf8(result, i + 6, size - 6)), item);
                 i += size + 4;
             }
             else if (prop.typeIndex === BINARY) {

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

@@ -2,16 +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 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;
-};
+const ENCODER = new TextEncoder();
 // vector
 export const vectorSearch = (def, q, field, opts) => {
     let prop = def.props[field];
@@ -23,7 +14,7 @@ export const vectorSearch = (def, q, field, opts) => {
     }
     // [isVec] [q len] [q len] [field] [fn] [score] [score] [score] [score] [q..]
     let size = 9;
-    const vec = Buffer.from(q.buffer);
+    const vec = new Uint8Array(q.buffer, 0, q.byteLength);
     size += vec.byteLength;
     def.search = {
         size: size,
@@ -33,23 +24,38 @@ 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 blocks = 0;
+    let nrBlocks = 0;
+    let totalByteLength = 1;
     if (typeof q !== 'string') {
         searchIncorrecQueryValue(def, q);
         q = '';
     }
-    const x = q.toLowerCase().trim().split(' ');
+    const x = q.toLowerCase().normalize('NFKD').trim().split(' ').map((s) => `  ${s}`);
     for (const s of x) {
         if (s) {
-            const b = Buffer.from(s);
-            bufs.push(makeSize(b.byteLength), b);
-            blocks++;
+            const buf = ENCODER.encode(s);
+            let len = buf.byteLength - 2;
+            buf[0] = len;
+            buf[1] = len >>> 8;
+            bufs.push(buf);
+            nrBlocks++;
+            totalByteLength += len + 2;
         }
     }
-    bufs.unshift(makeSize(blocks, true));
-    const query = Buffer.concat(bufs);
+    bufs.unshift(Uint8Array.from([nrBlocks]));
+    const query = concatBufs(bufs, totalByteLength);
     def.search = {
         size: query.byteLength + 3,
         query,
@@ -115,7 +121,7 @@ export const searchToBuffer = (search) => {
         result.writeUint16LE(search.query.byteLength, 1);
         result[3] = search.prop;
         result[4] = getVectorFn(search.opts.fn);
-        result.set(Buffer.from(new Float32Array([search.opts.score ?? 0.5]).buffer), 5);
+        result.set(new Uint8Array(new Float32Array([search.opts.score ?? 0.5]).buffer), 5);
         result.set(search.query, 9);
         return result;
     }

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

@@ -0,0 +1,4 @@
+import { QueryDef } from './types.js';
+import { SchemaTypesParsed } from '@based/schema/def';
+export declare const serialize: (q: QueryDef) => string;
+export declare const parse: (str: string, parsedSchema: SchemaTypesParsed) => void;

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

@@ -0,0 +1,26 @@
+const walk = (q) => {
+    const obj = {};
+    for (const key in q) {
+        if (key === 'schema') {
+            obj[key] = q[key].type;
+        }
+        else {
+            // if PROPDEF
+            if (typeof q[key] === 'object') {
+                obj[key] = walk(q[key]);
+            }
+            else {
+                obj[key] = q[key];
+            }
+        }
+    }
+    return obj;
+};
+export const serialize = (q) => {
+    const obj = walk(q);
+    return JSON.stringify(obj);
+};
+export const parse = (str, parsedSchema) => {
+    //
+};
+//# sourceMappingURL=serialize.js.map

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

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

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

@@ -1,15 +1,15 @@
 import { validateSort } from './validation.js';
 export const createSortBuffer = (sort) => {
-    const buf = Buffer.allocUnsafe(8);
+    const buf = new Uint8Array(8);
     // [order] [propType] [start] [start] [len] [len] [lang]
     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);
+    buf[3] = sort.prop.start;
+    buf[4] = sort.prop.start >>> 8;
+    buf[5] = sort.prop.len;
+    buf[6] = sort.prop.len >>> 8;
     buf[7] = sort.lang;
-    // console.info({ sort, buf: new Uint8Array(buf) })
-    //[LANG]
     return buf;
 };
 // NO REF / REFERENCES SUPPORT

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

@@ -16,7 +16,7 @@ export const resultsAreEqual = (a, b) => {
         return false;
     return true;
 };
-const EMPTY = new Uint8Array(Buffer.alloc(4));
+const EMPTY = new Uint8Array(4);
 export const runSubscription = (subscription) => {
     if (!subscription.inProgress) {
         subscription.inProgress = true;

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

@@ -30,6 +30,10 @@ export declare const isRefDef: (def: QueryDef) => def is QueryDefRest;
 export type QueryDefFilter = {
     size: number;
     conditions: Map<number, Buffer[]>;
+    exists?: {
+        prop: PropDef | PropDefEdge;
+        negate: boolean;
+    }[];
     references?: Map<number, QueryDefFilter>;
     fromRef?: PropDef;
     schema?: SchemaTypeDef;
@@ -39,7 +43,7 @@ export type QueryDefFilter = {
 };
 export type QueryDefSearch = {
     size: number;
-    query: Buffer;
+    query: Uint8Array;
     isVector: false;
     fields: {
         weight: number;
@@ -49,7 +53,7 @@ export type QueryDefSearch = {
     }[];
 } | {
     size: number;
-    query: Buffer;
+    query: Uint8Array;
     prop: number;
     isVector: true;
     opts: FilterOpts;