@based/db 0.0.8 → 0.0.9

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

@@ -1,16 +1,12 @@
 import { REFERENCE, REFERENCES, REVERSE_SIZE_MAP, } from '../../../server/schema/types.js';
-import { isNumerical, operationToByte } from './operators.js';
+import { EQUAL, isNumerical } from './types.js';
 import { createVariableFilterBuffer } from './createVariableFilterBuffer.js';
 import { createFixedFilterBuffer } from './createFixedFilterBuffer.js';
 import { createReferenceFilter } from './createReferenceFilter.js';
-import { checkOperator, checkValue } from '../validation.js';
 export const primitiveFilter = (prop, filter, conditions, lang) => {
-    let [, operator, value] = filter;
-    checkOperator(operator);
-    checkValue(value, operator);
+    let [, ctx, value] = filter;
     const fieldIndexChar = prop.prop;
     let buf;
-    const op = operationToByte(operator);
     let size = 0;
     const bufferMap = prop.__isEdge ? conditions.edges : conditions.conditions;
     const isArray = Array.isArray(value);
@@ -19,19 +15,19 @@ export const primitiveFilter = (prop, filter, conditions, lang) => {
     }
     const propSize = REVERSE_SIZE_MAP[prop.typeIndex];
     if (prop.typeIndex === REFERENCE) {
-        buf = createReferenceFilter(prop, op, value);
+        buf = createReferenceFilter(prop, ctx, value);
     }
     else if (prop.typeIndex === REFERENCES) {
-        if (op === 1 && !isArray) {
+        if (ctx.operation === EQUAL && !isArray) {
             value = [value];
         }
-        buf = createFixedFilterBuffer(prop, 4, op, value, !isNumerical(op));
+        buf = createFixedFilterBuffer(prop, 4, ctx, value, !isNumerical(ctx.operation));
     }
     else if (propSize) {
-        buf = createFixedFilterBuffer(prop, propSize, op, value, false);
+        buf = createFixedFilterBuffer(prop, propSize, ctx, value, false);
     }
     else {
-        buf = createVariableFilterBuffer(value, prop, op, lang);
+        buf = createVariableFilterBuffer(value, prop, ctx, lang);
     }
     // ADD OR if array for value
     let arr = bufferMap.get(fieldIndexChar);

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

@@ -1,7 +1,4 @@
-// -------------------------------------------
-// and
-// [meta = 255] [size 2]
-// -------------------------------------------
+import { META_EDGE, META_OR_BRANCH, META_REFERENCE } from './types.js';
 // or
 // [meta = 253]  [size 2] [next 4]
 // -------------------------------------------
@@ -43,7 +40,7 @@ export const fillConditionsBuffer = (result, conditions, offset) => {
     let lastWritten = offset;
     let orJumpIndex = 0;
     if (conditions.or) {
-        result[lastWritten] = 253;
+        result[lastWritten] = META_OR_BRANCH;
         lastWritten++;
         orJumpIndex = lastWritten;
         lastWritten += 2;
@@ -54,7 +51,7 @@ export const fillConditionsBuffer = (result, conditions, offset) => {
     });
     if (conditions.references) {
         for (const [refField, refConditions] of conditions.references) {
-            result[lastWritten] = 254;
+            result[lastWritten] = META_REFERENCE;
             lastWritten++;
             result[lastWritten] = refField;
             lastWritten++;
@@ -69,7 +66,7 @@ export const fillConditionsBuffer = (result, conditions, offset) => {
     }
     if (conditions.edges) {
         conditions.edges.forEach((v, k) => {
-            result[lastWritten] = 252;
+            result[lastWritten] = META_EDGE;
             lastWritten++;
             let sizeIndex = lastWritten;
             lastWritten += 2;
@@ -86,6 +83,7 @@ export const fillConditionsBuffer = (result, conditions, offset) => {
     }
     return lastWritten - offset;
 };
+// TODO convert to UINT8ARRAY
 export const filterToBuffer = (conditions) => {
     let result;
     if (conditions.size > 0) {

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

@@ -1,6 +1,55 @@
-import { Operator } from './operators.js';
 import { FilterBranch } from './FilterBranch.js';
-export type Filter = [fieldStr: string, operator: Operator, value: any];
+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 declare const validOperators: readonly ["=", "has", "!has", "<", ">", "!=", "like", ">=", "<=", "..", "!.."];
+export type Operator = '=' | 'has' | '!has' | '<' | '>' | '!=' | 'like' | '>=' | '<=' | '..' | '!..' | 'like';
+export type FilterOpts<O = Operator> = {
+    lowerCase?: boolean;
+    fn?: 'dotProduct' | 'manhattanDistance' | 'cosineSimilarity' | 'euclideanDistance';
+    score?: number;
+};
+export declare const EQUAL = 1;
+export declare const HAS = 2;
+export declare const ENDS_WITH = 4;
+export declare const STARTS_WITH = 5;
+export declare const EQUAL_CRC32 = 17;
+export declare const GREATER_THAN = 6;
+export declare const SMALLER_THAN = 7;
+export declare const GREATER_THAN_INCLUSIVE = 8;
+export declare const SMALLER_THAN_INCLUSIVE = 9;
+export declare const RANGE = 10;
+export declare const RANGE_EXCLUDE = 11;
+export declare const EQUAL_LOWER_CASE = 12;
+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 isNumerical: (op: OPERATOR) => boolean;
+export declare const TYPE_NEGATE = 1;
+export declare const TYPE_DEFAULT = 2;
+export type FILTER_TYPE = typeof TYPE_NEGATE | typeof TYPE_DEFAULT;
+export declare const MODE_DEFAULT = 0;
+export declare const MODE_OR_FIXED = 1;
+export declare const MODE_OR_VAR = 2;
+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_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 FilterCtx = {
+    operation: OPERATOR;
+    type: FILTER_TYPE;
+    opts: FilterOpts;
+};
+export declare const VECTOR_DOT_PRODUCT = 0;
+export declare const VECTOR_MANHATTAN_DIST = 1;
+export declare const VECTOR_COSTINE_SIMILARITY = 2;
+export declare const VECTOR_EUCLIDEAN_DIST = 3;
+export declare const getVectorFn: (optsFn?: FilterOpts["fn"]) => 1 | 2 | 3 | 0;
+export declare const toFilterCtx: (op: Operator, opts?: FilterOpts) => FilterCtx;

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

@@ -4,4 +4,118 @@ export const IsFilter = (f) => {
     }
     return false;
 };
+export const validOperators = [
+    '=',
+    'has',
+    '!has',
+    '<',
+    '>',
+    '!=',
+    'like',
+    '>=',
+    '<=',
+    '..',
+    '!..',
+];
+// -------------------------------------------
+// operations shared
+export const EQUAL = 1;
+export const HAS = 2;
+export const ENDS_WITH = 4;
+export const STARTS_WITH = 5;
+export const EQUAL_CRC32 = 17;
+// -------------------------------------------
+// operations numbers
+export const GREATER_THAN = 6;
+export const SMALLER_THAN = 7;
+export const GREATER_THAN_INCLUSIVE = 8;
+export const SMALLER_THAN_INCLUSIVE = 9;
+export const RANGE = 10;
+export const RANGE_EXCLUDE = 11;
+// -------------------------------------------
+// operations strings
+export const EQUAL_LOWER_CASE = 12;
+export const HAS_TO_LOWER_CASE = 13;
+export const STARTS_WITH_LOWER_CASE = 14;
+export const ENDS_WITH_LOWER_CASE = 15;
+export const LIKE = 18;
+// -------------------------------------------
+export const isNumerical = (op) => {
+    if (op === GREATER_THAN ||
+        op === SMALLER_THAN ||
+        op === SMALLER_THAN_INCLUSIVE ||
+        op === GREATER_THAN_INCLUSIVE ||
+        op === RANGE ||
+        op === RANGE_EXCLUDE) {
+        return true;
+    }
+    return false;
+};
+// -------------------------------------------
+// Types
+export const TYPE_NEGATE = 1;
+export const TYPE_DEFAULT = 2;
+// -------------------------------------------
+// Modes
+export const MODE_DEFAULT = 0;
+export const MODE_OR_FIXED = 1;
+export const MODE_OR_VAR = 2;
+export const MODE_AND_FIXED = 3;
+export const MODE_DEFAULT_VAR = 4;
+export const MODE_REFERENCE = 5;
+// -------------------------------------------
+// Meta
+export const META_EDGE = 252;
+export const META_OR_BRANCH = 253;
+export const META_REFERENCE = 254;
+export const VECTOR_DOT_PRODUCT = 0;
+export const VECTOR_MANHATTAN_DIST = 1;
+export const VECTOR_COSTINE_SIMILARITY = 2;
+export const VECTOR_EUCLIDEAN_DIST = 3;
+export const getVectorFn = (optsFn) => {
+    if (!optsFn) {
+        return VECTOR_COSTINE_SIMILARITY;
+    }
+    if (optsFn === 'dotProduct') {
+        return VECTOR_DOT_PRODUCT;
+    }
+    else if (optsFn === 'euclideanDistance') {
+        return VECTOR_EUCLIDEAN_DIST;
+    }
+    else if (optsFn === 'manhattanDistance') {
+        return VECTOR_MANHATTAN_DIST;
+    }
+};
+export const toFilterCtx = (op, opts = {}) => {
+    if (op === '=' || op === '!=') {
+        return {
+            operation: EQUAL,
+            type: op === '!=' ? TYPE_NEGATE : TYPE_DEFAULT,
+            opts,
+        };
+    }
+    if (op === 'has' || op === '!has') {
+        return {
+            operation: opts.lowerCase ? HAS_TO_LOWER_CASE : HAS,
+            type: op === '!has' ? TYPE_NEGATE : TYPE_DEFAULT,
+            opts,
+        };
+    }
+    if (op === '>') {
+        return { operation: GREATER_THAN, opts, type: TYPE_DEFAULT };
+    }
+    if (op === '<') {
+        return { operation: SMALLER_THAN, opts, type: TYPE_DEFAULT };
+    }
+    if (op === '>=') {
+        return { operation: GREATER_THAN_INCLUSIVE, opts, type: TYPE_DEFAULT };
+    }
+    if (op === '<=') {
+        return { operation: SMALLER_THAN_INCLUSIVE, opts, type: TYPE_DEFAULT };
+    }
+    if (op === 'like') {
+        return { operation: LIKE, opts, type: TYPE_DEFAULT };
+    }
+    throw new Error('Invalid filter operator');
+};
 //# sourceMappingURL=types.js.map

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

@@ -1,6 +1,8 @@
 import { PropDef, PropDefEdge } from '../../../server/schema/types.js';
 import { QueryDef } from '../types.js';
 export declare const getAll: (props: QueryDef["props"]) => string[];
+export declare const getAllRefs: (props: QueryDef["props"], affix?: string) => string[];
+export declare const includeField: (def: QueryDef, field: string) => void;
 export declare const includeFields: (def: QueryDef, fields: string[]) => void;
 export declare const includeAllProps: (def: QueryDef) => void;
 export declare const includeProp: (def: QueryDef, prop: PropDef | PropDefEdge) => boolean;

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

@@ -9,14 +9,33 @@ export const getAll = (props) => {
     }
     return fields;
 };
+export const getAllRefs = (props, affix = '') => {
+    const fields = [];
+    for (const key in props) {
+        const prop = props[key];
+        if (prop.typeIndex === REFERENCE || prop.typeIndex === REFERENCES) {
+            fields.push(prop.path.join('.') + affix);
+        }
+    }
+    return fields;
+};
+export const includeField = (def, field) => {
+    if (field === '*') {
+        includeFields(def, getAll(def.props));
+    }
+    else if (field === '**') {
+        includeFields(def, getAllRefs(def.props));
+    }
+    else if (field.startsWith('**.')) {
+        includeFields(def, getAllRefs(def.props, field.substring(2)));
+    }
+    else {
+        def.include.stringFields.add(field);
+    }
+};
 export const includeFields = (def, fields) => {
     for (const field of fields) {
-        if (field === '*') {
-            includeFields(def, getAll(def.props));
-        }
-        else {
-            def.include.stringFields.add(field);
-        }
+        includeField(def, field);
     }
 };
 export const includeAllProps = (def) => {

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

@@ -5,7 +5,8 @@ export const includeToBuffer = (db, def) => {
     if (!def.include.stringFields.size &&
         !def.include.props.size &&
         !def.references.size &&
-        !def.include.main.len) {
+        !def.include.main.len &&
+        !def.include.langTextFields.size) {
         return result;
     }
     let mainBuffer;
@@ -46,6 +47,25 @@ export const includeToBuffer = (db, def) => {
             }
         }
     }
+    if (def.include.langTextFields.size) {
+        for (const [prop, langCode] of def.include.langTextFields.entries()) {
+            def.include.propsRead[prop] = 0;
+            if (langCode.has(0)) {
+                const b = Buffer.allocUnsafe(2);
+                b[0] = prop;
+                b[1] = 0;
+                result.push(b);
+            }
+            else {
+                for (const code of langCode) {
+                    const b = Buffer.allocUnsafe(2);
+                    b[0] = prop;
+                    b[1] = code;
+                    result.push(b);
+                }
+            }
+        }
+    }
     const propSize = def.include.props.size ?? 0;
     if (mainBuffer) {
         len = mainBuffer.byteLength + 3 + propSize;

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

@@ -1,8 +1,9 @@
-import { isPropDef, REFERENCE, REFERENCES, } from '../../../server/schema/types.js';
+import { isPropDef, REFERENCE, REFERENCES, TEXT, } from '../../../server/schema/types.js';
 import { createQueryDef } from '../queryDef.js';
 import { isRefDef, QueryDefType } from '../types.js';
 import { getAllFieldFromObject, createOrGetRefQueryDef } from './utils.js';
 import { includeFields, includeProp, includeAllProps } from './props.js';
+import { langCodesMap } from '@based/schema';
 export const walkDefs = (db, def, f) => {
     const prop = def.props[f];
     const path = f.split('.');
@@ -41,7 +42,15 @@ export const walkDefs = (db, def, f) => {
             if (!t) {
                 return;
             }
-            if (isPropDef(t) &&
+            if (isPropDef(t) && t.typeIndex === TEXT) {
+                const langCode = langCodesMap.get(path[path.length - 1]);
+                if (!def.include.langTextFields.has(t.prop)) {
+                    def.include.langTextFields.set(t.prop, new Set());
+                }
+                def.include.langTextFields.get(t.prop).add(langCode);
+                return;
+            }
+            else if (isPropDef(t) &&
                 (t.typeIndex === REFERENCE || t.typeIndex === REFERENCES)) {
                 const refDef = createOrGetRefQueryDef(db, def, t);
                 const f = path.slice(i + 1).join('.');
@@ -64,6 +73,12 @@ export const walkDefs = (db, def, f) => {
         includeAllProps(refDef);
         return;
     }
+    else if (prop.typeIndex === TEXT) {
+        if (!def.include.langTextFields.has(prop.prop)) {
+            def.include.langTextFields.set(prop.prop, new Set());
+        }
+        def.include.langTextFields.get(prop.prop).add(def.lang ?? 0);
+    }
     else {
         includeProp(def, prop);
     }

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

@@ -7,6 +7,7 @@ const createEmptySharedDef = () => {
         range: { offset: 0, limit: 0 },
         lang: langCodesMap.get('none'),
         include: {
+            langTextFields: new Map(),
             stringFields: new Set(),
             props: new Set(),
             propsRead: {},

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

@@ -1,7 +1,7 @@
-import { ALIAS, ALIASES, BINARY, BOOLEAN, ENUM, INT16, INT32, INT8, NUMBER, STRING, TEXT, TIMESTAMP, UINT16, UINT32, UINT8, VECTOR, } from '../../../server/schema/types.js';
+import { ALIAS, ALIASES, BINARY, BOOLEAN, ENUM, INT16, INT32, INT8, NUMBER, STRING, TEXT, TIMESTAMP, UINT16, UINT32, UINT8, VECTOR, JSON, } from '../../../server/schema/types.js';
 import { read, readUtf8 } from '../../string.js';
 import { readDoubleLE, readFloatLE, readInt16, readInt32, readUint16, readUint32, } from '../../bitWise.js';
-import { inverseLangMap, langCodesMap } from '@based/schema';
+import { inverseLangMap } from '@based/schema';
 const addField = (p, value, item, defaultOnly = false, lang = 0) => {
     let i = p.__isEdge === true ? 1 : 0;
     // TODO OPTMIZE
@@ -28,6 +28,35 @@ const addField = (p, value, item, defaultOnly = false, lang = 0) => {
         }
     }
 };
+const getEmptyField = (p, item) => {
+    let i = p.__isEdge === true ? 1 : 0;
+    const path = p.path;
+    const len = path.length;
+    let select = item;
+    if (len - i === 1) {
+        const field = path[i];
+        if (!(field in item)) {
+            select = item[field] = {};
+        }
+        else {
+            return item[field];
+        }
+    }
+    else {
+        for (; i < len; i++) {
+            const field = path[i];
+            if (i === len - 1) {
+                if (!(field in select)) {
+                    select = select[field] = {};
+                }
+            }
+            else {
+                select = select[field] ?? (select[field] = {});
+            }
+        }
+    }
+    return select;
+};
 const readMainValue = (prop, result, index, item) => {
     // 1: timestamp, 4: number
     if (prop.typeIndex === TIMESTAMP || prop.typeIndex === NUMBER) {
@@ -52,7 +81,7 @@ const readMainValue = (prop, result, index, item) => {
     }
     // 11: string
     else if (prop.typeIndex === STRING) {
-        // Also remove this default then (same as other string)
+        // Also delete this default then (same as other string)
         const len = result[index];
         if (len !== 0) {
             const str = readUtf8(result, index + 1, len);
@@ -62,6 +91,10 @@ const readMainValue = (prop, result, index, item) => {
             addField(prop, '', item);
         }
     }
+    // ?: json
+    else if (prop.typeIndex === JSON) {
+        addField(prop, global.JSON.parse(Buffer.from(result.subarray(index + 1, index + 1 + result[index])).toString()), item);
+    }
     // 25: binary
     else if (prop.typeIndex === BINARY) {
         addField(prop, result.subarray(index + 1, index + 1 + result[index]), item);
@@ -109,7 +142,29 @@ const readMain = (q, result, offset, item) => {
 const handleUndefinedProps = (id, q, item) => {
     for (const k in q.include.propsRead) {
         if (q.include.propsRead[k] !== id) {
-            addField(q.schema.reverseProps[k], '', item);
+            const prop = q.schema.reverseProps[k];
+            if (prop.typeIndex === TEXT && q.lang == 0) {
+                const lan = getEmptyField(prop, item);
+                const lang = q.include.langTextFields.get(prop.prop);
+                if (lang.has(0)) {
+                    for (const locale in q.schema.locales) {
+                        if (!lan[locale]) {
+                            lan[locale] = '';
+                        }
+                    }
+                }
+                else {
+                    for (const code of lang) {
+                        const locale = inverseLangMap.get(code);
+                        if (!lan[locale]) {
+                            lan[locale] = '';
+                        }
+                    }
+                }
+            }
+            else {
+                addField(prop, prop.typeIndex === JSON ? null : '', item);
+            }
         }
     }
 };
@@ -118,12 +173,15 @@ export const readAllFields = (q, result, offset, end, item, id) => {
     while (i < end) {
         const index = result[i];
         i++;
+        // index:255 id
         if (index === 255) {
             handleUndefinedProps(id, q, item);
             return i - offset;
         }
+        // index:252 edge
         if (index === 252) {
             let prop = result[i];
+            // index:254 ref
             if (prop === 254) {
                 i++;
                 const field = result[i];
@@ -148,6 +206,7 @@ export const readAllFields = (q, result, offset, end, item, id) => {
                     addField(ref.target.propDef, refItem, item);
                     i += size - 5;
                 }
+                // index:253 refs
             }
             else if (prop === 253) {
                 i++;
@@ -165,7 +224,13 @@ export const readAllFields = (q, result, offset, end, item, id) => {
             else {
                 const edgeDef = q.edges.reverseProps[prop];
                 const t = edgeDef.typeIndex;
-                if (t === BINARY) {
+                if (t === JSON) {
+                    i++;
+                    const size = readUint32(result, i);
+                    addField(edgeDef, global.JSON.parse(Buffer.from(result.subarray(i + 6, size + i)).toString()), item);
+                    i += size + 4;
+                }
+                else if (t === BINARY) {
                     i++;
                     const size = readUint32(result, i);
                     addField(edgeDef, result.subarray(i + 6, size + i), item);
@@ -188,6 +253,7 @@ export const readAllFields = (q, result, offset, end, item, id) => {
                     i += edgeDef.len;
                 }
             }
+            // index:254 ref
         }
         else if (index === 254) {
             const field = result[i];
@@ -212,6 +278,7 @@ export const readAllFields = (q, result, offset, end, item, id) => {
                 addField(ref.target.propDef, refItem, item);
                 i += size - 5;
             }
+            // index:253 refs
         }
         else if (index === 253) {
             const field = result[i];
@@ -229,7 +296,13 @@ export const readAllFields = (q, result, offset, end, item, id) => {
         }
         else {
             const prop = q.schema.reverseProps[index];
-            if (prop.typeIndex === BINARY) {
+            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);
+                i += size + 4;
+            }
+            else if (prop.typeIndex === BINARY) {
                 q.include.propsRead[index] = id;
                 const size = readUint32(result, i);
                 addField(prop, result.subarray(i + 6, i + size), item);
@@ -247,29 +320,20 @@ export const readAllFields = (q, result, offset, end, item, id) => {
                 i += size + 4;
             }
             else if (prop.typeIndex == TEXT) {
-                q.include.propsRead[index] = id;
                 const size = readUint32(result, i);
-                // if queryDef.LANG do different
                 if (size === 0) {
-                    // LATER
-                    // addField(prop, '', item)
                 }
                 else {
-                    if (q.lang != langCodesMap.get('none')) {
+                    if (q.lang != 0) {
+                        q.include.propsRead[index] = id;
                         addField(prop, read(result, i + 4, size), item);
                     }
                     else {
+                        // q.include.propsRead[index] = id
                         addField(prop, read(result, i + 4, size), item, false, result[i + 4]);
                     }
                 }
-                const lan = 
-                // TODO Read text
-                //if (size === 0) {
-                //  addField(prop, '', item)
-                //} else {
-                //  addField(prop, read(result, i + 4, size), item)
-                //}
-                (i += size + 4);
+                i += size + 4;
             }
             else if (prop.typeIndex === ALIAS) {
                 q.include.propsRead[index] = id;
@@ -314,8 +378,8 @@ export const resultToObject = (q, result, end, offset = 0) => {
             id,
         };
         if (q.search) {
-            item.$searchScore = result[i];
-            i += 1;
+            item.$searchScore = readFloatLE(result, i);
+            i += 4;
         }
         const l = readAllFields(q, result, i, end, item, id);
         i += l;

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

@@ -1,6 +1,8 @@
 import { QueryDefSearch, QueryDef } from '../types.js';
+import { FilterOpts } from '../filter/types.js';
 export type Search = string[] | {
     [field: string]: number;
 } | 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;