@based/db 0.0.68 → 0.0.70

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

@@ -3,9 +3,9 @@ import { BINARY, BOOLEAN, ENUM, INT16, INT32, INT8, NUMBER, STRING, TIMESTAMP, U
 import { convertToTimestamp } from '@saulx/utils';
 import { getBuffer } from './binary.js';
 import { ModifyError } from './ModifyRes.js';
-import { RANGE_ERR } from './types.js';
+import { MOD_OPS_TO_STRING, RANGE_ERR } from './types.js';
 const map = {};
-map[BINARY] = (ctx, val, def) => {
+map[BINARY] = (ctx, val, def, mod) => {
     const buf = getBuffer(val);
     if (buf === undefined) {
         return new ModifyError(def, val);
@@ -13,6 +13,9 @@ map[BINARY] = (ctx, val, def) => {
     if (!def.validation(val, def)) {
         return new ModifyError(def, val);
     }
+    if (def.transform) {
+        val = def.transform(MOD_OPS_TO_STRING[mod], val);
+    }
     const size = buf.byteLength;
     if (ctx.len + size + 1 > ctx.max) {
         return RANGE_ERR;
@@ -21,7 +24,7 @@ map[BINARY] = (ctx, val, def) => {
     ctx.buf.set(buf, ctx.len);
     ctx.len += buf.byteLength;
 };
-map[STRING] = (ctx, val, def) => {
+map[STRING] = (ctx, val, def, mod) => {
     const valBuf = ENCODER.encode(val);
     const size = valBuf.byteLength;
     if (size + 1 > def.len) {
@@ -30,6 +33,9 @@ map[STRING] = (ctx, val, def) => {
     if (!def.validation(val, def)) {
         return new ModifyError(def, val);
     }
+    if (def.transform) {
+        val = def.transform(MOD_OPS_TO_STRING[mod], val);
+    }
     if (ctx.len + size + 1 > ctx.max) {
         return RANGE_ERR;
     }
@@ -41,30 +47,36 @@ map[STRING] = (ctx, val, def) => {
         ctx.buf.fill(0, ctx.len - (fullSize - size), ctx.len);
     }
 };
-map[BOOLEAN] = (ctx, val, def) => {
+map[BOOLEAN] = (ctx, val, def, mod) => {
     if (ctx.len + 1 > ctx.max) {
         return RANGE_ERR;
     }
+    if (val === null) {
+        val = def.default;
+    }
     if (!def.validation(val, def)) {
         return new ModifyError(def, val);
     }
-    if (val === null) {
-        ctx.buf[ctx.len++] = 0;
+    if (def.transform) {
+        val = def.transform(MOD_OPS_TO_STRING[mod], val);
     }
-    else if (typeof val === 'boolean') {
+    if (typeof val === 'boolean') {
         ctx.buf[ctx.len++] = val ? 1 : 0;
     }
     else {
         return new ModifyError(def, val);
     }
 };
-map[ENUM] = (ctx, val, def) => {
+map[ENUM] = (ctx, val, def, mod) => {
     if (ctx.len + 1 > ctx.max) {
         return RANGE_ERR;
     }
     if (!def.validation(val, def)) {
         return new ModifyError(def, val);
     }
+    if (def.transform) {
+        val = def.transform(MOD_OPS_TO_STRING[mod], val);
+    }
     if (val === null) {
         ctx.buf[ctx.len++] = 0;
     }
@@ -75,101 +87,149 @@ map[ENUM] = (ctx, val, def) => {
         return new ModifyError(def, val);
     }
 };
-map[NUMBER] = (ctx, val, def) => {
+map[NUMBER] = (ctx, val, def, mod) => {
     if (ctx.len + 8 > ctx.max) {
         return RANGE_ERR;
     }
+    if (val === null) {
+        val = def.default;
+    }
     if (!def.validation(val, def)) {
         return new ModifyError(def, val);
     }
+    if (def.transform) {
+        val = def.transform(MOD_OPS_TO_STRING[mod], val);
+    }
     const view = new DataView(ctx.buf.buffer, ctx.buf.byteOffset + ctx.len, 8);
     ctx.len += 8;
     view.setFloat64(0, val, true);
 };
-map[TIMESTAMP] = (ctx, val, def) => {
+map[TIMESTAMP] = (ctx, val, def, mod) => {
     const parsedValue = convertToTimestamp(val);
     if (ctx.len + 8 > ctx.max) {
         return RANGE_ERR;
     }
+    if (val === null) {
+        val = def.default;
+    }
     if (!def.validation(parsedValue, def)) {
         return new ModifyError(def, val);
     }
+    if (def.transform) {
+        val = def.transform(MOD_OPS_TO_STRING[mod], val);
+    }
     const view = new DataView(ctx.buf.buffer, ctx.buf.byteOffset + ctx.len, 8);
     ctx.len += 8;
     // Todo use new utils and store as uint64
     view.setFloat64(0, parsedValue, true);
     // const ts = view.getFloat64(0)
 };
-map[UINT32] = (ctx, val, def) => {
+map[UINT32] = (ctx, val, def, mod) => {
     if (ctx.len + 4 > ctx.max) {
         return RANGE_ERR;
     }
+    if (val === null) {
+        val = def.default;
+    }
     if (!def.validation(val, def)) {
         return new ModifyError(def, val);
     }
+    if (def.transform) {
+        val = def.transform(MOD_OPS_TO_STRING[mod], val);
+    }
     ctx.buf[ctx.len++] = val;
     ctx.buf[ctx.len++] = val >>>= 8;
     ctx.buf[ctx.len++] = val >>>= 8;
     ctx.buf[ctx.len++] = val >>>= 8;
 };
-map[UINT16] = (ctx, val, def) => {
+map[UINT16] = (ctx, val, def, mod) => {
     if (ctx.len + 2 > ctx.max) {
         return RANGE_ERR;
     }
+    if (val === null) {
+        val = def.default;
+    }
     if (!def.validation(val, def)) {
         return new ModifyError(def, val);
     }
+    if (def.transform) {
+        val = def.transform(MOD_OPS_TO_STRING[mod], val);
+    }
     ctx.buf[ctx.len++] = val;
     ctx.buf[ctx.len++] = val >>>= 8;
 };
-map[UINT8] = (ctx, val, def) => {
+map[UINT8] = (ctx, val, def, mod) => {
     if (ctx.len + 1 > ctx.max) {
         return RANGE_ERR;
     }
+    if (val === null) {
+        val = def.default;
+    }
     if (!def.validation(val, def)) {
         return new ModifyError(def, val);
     }
+    if (def.transform) {
+        val = def.transform(MOD_OPS_TO_STRING[mod], val);
+    }
     ctx.buf[ctx.len++] = val;
 };
-map[INT32] = (ctx, val, def) => {
+map[INT32] = (ctx, val, def, mod) => {
     if (ctx.len + 4 > ctx.max) {
         return RANGE_ERR;
     }
+    if (val === null) {
+        val = def.default;
+    }
     if (!def.validation(val, def)) {
         return new ModifyError(def, val);
     }
+    if (def.transform) {
+        val = def.transform(MOD_OPS_TO_STRING[mod], val);
+    }
     ctx.buf[ctx.len++] = val;
     ctx.buf[ctx.len++] = val >>>= 8;
     ctx.buf[ctx.len++] = val >>>= 8;
     ctx.buf[ctx.len++] = val >>>= 8;
 };
-map[INT16] = (ctx, val, def) => {
+map[INT16] = (ctx, val, def, mod) => {
     if (ctx.len + 2 > ctx.max) {
         return RANGE_ERR;
     }
+    if (val === null) {
+        val = def.default;
+    }
     if (!def.validation(val, def)) {
         return new ModifyError(def, val);
     }
+    if (def.transform) {
+        val = def.transform(MOD_OPS_TO_STRING[mod], val);
+    }
     ctx.buf[ctx.len++] = val;
     ctx.buf[ctx.len++] = val >>>= 8;
 };
-map[INT8] = (ctx, val, def) => {
+map[INT8] = (ctx, val, def, mod) => {
     if (ctx.len + 1 > ctx.max) {
         return RANGE_ERR;
     }
+    if (val === null) {
+        val = def.default;
+    }
     if (!def.validation(val, def)) {
         return new ModifyError(def, val);
     }
+    if (def.transform) {
+        val = def.transform(MOD_OPS_TO_STRING[mod], val);
+    }
     ctx.buf[ctx.len++] = val;
 };
-export const writeFixedValue = (ctx, val, def, pos) => {
+export const writeFixedValue = (ctx, value, def, pos, mod) => {
     const len = ctx.len;
     ctx.len = pos;
-    const res = map[def.typeIndex](ctx, val, def);
+    const res = map[def.typeIndex](ctx, value, def, mod);
     ctx.len = len;
     return res;
 };
-export const appendFixedValue = (ctx, val, def) => {
-    return map[def.typeIndex](ctx, val, def);
+export const appendFixedValue = (ctx, val, def, mod) => {
+    return map[def.typeIndex](ctx, val, def, mod);
 };
 //# sourceMappingURL=fixed.js.map

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

@@ -1,3 +1,4 @@
+import { CREATE } from './types.js';
 import { writeBinary } from './binary.js';
 import { ModifyError } from './ModifyRes.js';
 export function writeJson(value, ctx, schema, t, parentId, modifyOp) {
@@ -9,6 +10,12 @@ export function writeJson(value, ctx, schema, t, parentId, modifyOp) {
             if (!t.validation(value, t)) {
                 return new ModifyError(t, value);
             }
+            if (modifyOp === CREATE) {
+                if (schema.hasSeperateDefaults) {
+                    schema.seperateDefaults.bufferTmp[t.prop] = 1;
+                    ctx.hasDefaults++;
+                }
+            }
             return writeBinary(JSON.stringify(value), ctx, schema, t, parentId, modifyOp);
         }
     }

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

@@ -75,10 +75,10 @@ function _modify(ctx, res, obj, schema, mod, tree, overwrite, unsafe) {
                     ctx.len += schema.mainLen;
                 }
                 if (typeof val === 'object' && val !== null && 'increment' in val) {
-                    err = writeFixedValue(ctx, val.increment, def, ctx.lastMain + def.start);
+                    err = writeFixedValue(ctx, val.increment, def, ctx.lastMain + def.start, mod);
                 }
                 else {
-                    err = writeFixedValue(ctx, val, def, ctx.lastMain + def.start);
+                    err = writeFixedValue(ctx, val, def, ctx.lastMain + def.start, mod);
                 }
             }
             else if (typeof val === 'object' && val !== null) {
@@ -102,7 +102,7 @@ function _modify(ctx, res, obj, schema, mod, tree, overwrite, unsafe) {
                     ctx.buf[ctx.len++] = def.typeIndex;
                     ctx.buf[ctx.len++] = start;
                     ctx.buf[ctx.len++] = start >>>= 8;
-                    appendFixedValue(ctx, increment, def);
+                    appendFixedValue(ctx, increment, def, mod);
                 }
                 else {
                     return new ModifyError(def, val);

package/dist/src/client/modify/references/edge.js

@@ -198,7 +198,7 @@ export function writeEdges(t, ref, ctx) {
                 ctx.buf[ctx.len++] = sizeU32 >>>= 8;
                 ctx.buf[ctx.len++] = sizeU32 >>>= 8;
                 ctx.buf[ctx.len++] = sizeU32 >>>= 8;
-                const err = appendFixedValue(ctx, value, edge);
+                const err = appendFixedValue(ctx, value, edge, UPDATE);
                 if (err) {
                     return err;
                 }
@@ -251,7 +251,7 @@ export function writeEdges(t, ref, ctx) {
             ctx.buf[ctx.len++] = sizeU32 >>>= 8;
             for (let i = 0; i < mainFields.length; i += 3) {
                 const edge = mainFields[i];
-                const err = appendFixedValue(ctx, mainFields[i + 1], edge);
+                const err = appendFixedValue(ctx, mainFields[i + 1], edge, UPDATE);
                 if (err) {
                     return err;
                 }
@@ -309,7 +309,7 @@ export function writeEdges(t, ref, ctx) {
                 ctx.buf[sIndexI + 5] = edge.typeIndex;
                 ctx.len = startMain + edge.start;
                 // Add null support (defaults)
-                const err = appendFixedValue(ctx, value, edge);
+                const err = appendFixedValue(ctx, value, edge, op);
                 if (err) {
                     return err;
                 }

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 | Uint8Array, ctx: ModifyCtx, def: SchemaTypeDef, t: PropDef, parentId: number, modifyOp: ModifyOp): ModifyErr;
+export declare function writeString(lang: LangCode, value: string | null | Uint8Array, ctx: ModifyCtx, schema: SchemaTypeDef, t: PropDef, parentId: number, modifyOp: ModifyOp): ModifyErr;

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

@@ -1,19 +1,19 @@
 import { ENCODER } from '../../index.js';
-import { CREATE, UPDATE, RANGE_ERR, DELETE, DELETE_TEXT_FIELD, } from './types.js';
+import { CREATE, UPDATE, RANGE_ERR, DELETE, DELETE_TEXT_FIELD, MOD_OPS_TO_STRING, } from './types.js';
 import { ModifyError } from './ModifyRes.js';
 import { setCursor } from './setCursor.js';
 import { write } from '../string.js';
 // allow setting buffer in modify create for strings
 // add compression handling for main buffer
 // add compression handling for edge fields
-export function writeString(lang, value, ctx, def, t, parentId, modifyOp) {
+export function writeString(lang, value, ctx, schema, t, parentId, modifyOp) {
     const isBuffer = value instanceof Uint8Array;
     if (value === null || value === '') {
         if (modifyOp === UPDATE) {
             if (ctx.len + 11 /* SIZE.DEFAULT_CURSOR */ + 2 > ctx.max) {
                 return RANGE_ERR;
             }
-            setCursor(ctx, def, t.prop, t.typeIndex, parentId, modifyOp);
+            setCursor(ctx, schema, t.prop, t.typeIndex, parentId, modifyOp);
             if (lang === 0) {
                 ctx.buf[ctx.len++] = DELETE;
             }
@@ -27,22 +27,32 @@ export function writeString(lang, value, ctx, def, t, parentId, modifyOp) {
         if (!t.validation(value, t)) {
             return new ModifyError(t, value);
         }
+        if (t.transform) {
+            value = t.transform(MOD_OPS_TO_STRING[modifyOp], value);
+        }
         let size = isBuffer
-            ? value.byteLength
-            : ENCODER.encode(value).byteLength + 6;
+            ? // @ts-ignore
+                value.byteLength
+            : // @ts-ignore
+                ENCODER.encode(value).byteLength + 6;
         if (ctx.len + 11 /* SIZE.DEFAULT_CURSOR */ + 11 + size > ctx.max) {
             return RANGE_ERR;
         }
         if (modifyOp === CREATE) {
-            def.seperateSort.bufferTmp[t.prop] = 2;
+            schema.seperateSort.bufferTmp[t.prop] = 2;
             ctx.hasSortField++;
+            if (schema.hasSeperateDefaults) {
+                schema.seperateDefaults.bufferTmp[t.prop] = 1;
+                ctx.hasDefaults++;
+            }
         }
-        setCursor(ctx, def, t.prop, t.typeIndex, parentId, modifyOp);
+        setCursor(ctx, schema, t.prop, t.typeIndex, parentId, modifyOp);
         // TODO if buffer check if second byte is zero or one
         // modOp | size u32 | stringprotocol | string
         ctx.buf[ctx.len] = modifyOp;
         ctx.len += 5;
         if (isBuffer) {
+            // @ts-ignore
             ctx.buf.set(value, ctx.len);
         }
         else {

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];
-} | Parameters<typeof writeString>[1], ctx: ModifyCtx, def: SchemaTypeDef, t: PropDef, res: ModifyState, parentId: number, modifyOp: ModifyOp): ModifyErr;
+} | Parameters<typeof writeString>[1], ctx: ModifyCtx, schema: SchemaTypeDef, t: PropDef, res: ModifyState, id: number, modifyOp: ModifyOp): ModifyErr;

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

@@ -2,13 +2,13 @@ import { CREATE, UPDATE, RANGE_ERR, DELETE, } from './types.js';
 import { writeString } from './string.js';
 import { ModifyError } from './ModifyRes.js';
 import { setCursor } from './setCursor.js';
-export function writeText(value, ctx, def, t, res, parentId, modifyOp) {
+export function writeText(value, ctx, schema, t, res, id, modifyOp) {
     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);
+            setCursor(ctx, schema, t.prop, t.typeIndex, id, modifyOp);
             ctx.buf[ctx.len++] = DELETE;
         }
         return;
@@ -17,40 +17,52 @@ export function writeText(value, ctx, def, t, res, parentId, modifyOp) {
         let locale = res.locale;
         if (!locale) {
             // TODO: Add def lang option...
-            for (const localeCode of def.seperateTextSort.localeToIndex.keys()) {
+            for (const localeCode of schema.seperateTextSort.localeToIndex.keys()) {
                 locale = localeCode;
                 break;
             }
         }
-        if (!def.seperateTextSort.localeToIndex.has(locale)) {
+        if (!schema.seperateTextSort.localeToIndex.has(locale)) {
             return new ModifyError(t, locale, 'Invalid locale');
         }
-        const err = writeString(locale, value, ctx, def, t, res.tmpId, modifyOp);
+        const err = writeString(locale, value, ctx, schema, t, res.tmpId, modifyOp);
         if (modifyOp === CREATE) {
-            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;
+            const index = t.prop * (schema.localeSize + 1);
+            const langIndex = schema.seperateTextSort.localeToIndex.get(locale);
+            schema.seperateTextSort.bufferTmp[index] -= 1;
+            schema.seperateTextSort.bufferTmp[index + langIndex] = 0;
             ctx.hasSortText += 1;
+            if (schema.hasSeperateDefaults) {
+                schema.seperateDefaults.bufferTmp[t.prop] = 1;
+                ctx.hasDefaults++;
+            }
         }
         return err;
     }
     else {
+        if (modifyOp === CREATE && schema.hasSeperateDefaults) {
+            ctx.hasDefaults++;
+        }
         // @ts-ignore
         for (const lang in value) {
-            const langC = def.seperateTextSort.localeStringToIndex.get(lang);
+            const langC = schema.seperateTextSort.localeStringToIndex.get(lang);
             if (!langC) {
                 return new ModifyError(t, lang, 'Invalid locale');
             }
             let s = value[lang];
-            const err = writeString(langC[1], s, ctx, def, t, res.tmpId, modifyOp);
+            const err = writeString(langC[1], s, ctx, schema, 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;
+            if (modifyOp === CREATE) {
+                const index = t.prop * (1 + schema.localeSize);
+                schema.seperateTextSort.bufferTmp[index] -= 1;
+                schema.seperateTextSort.bufferTmp[index + langC[0]] = 0;
+                ctx.hasSortText += 1;
+                if (schema.hasSeperateDefaults) {
+                    schema.seperateDefaults.bufferTmp[t.prop]++;
+                }
+            }
         }
     }
 }

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

@@ -17,11 +17,12 @@ 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 type ModifyOp = typeof CREATE | typeof UPDATE | typeof INCREMENT | typeof EXPIRE;
+export declare const MOD_OPS_TO_STRING: Record<ModifyOp, 'create' | 'update'>;
 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 = {
     unsafe?: boolean;
     locale?: LangName;

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

@@ -15,6 +15,12 @@ export const SWITCH_TYPE = 2;
 export const SWITCH_FIELD = 0;
 export const SWITCH_ID_CREATE = 9;
 export const SWITCH_ID_UPDATE = 1;
+export const MOD_OPS_TO_STRING = {
+    [CREATE]: 'create',
+    [UPDATE]: 'update',
+    [INCREMENT]: 'update',
+    [EXPIRE]: 'update',
+};
 export const NOEDGE_NOINDEX_REALID = 0;
 export const EDGE_NOINDEX_REALID = 1;
 export const EDGE_INDEX_REALID = 2;

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

@@ -5,6 +5,7 @@ import { modify } from './modify.js';
 import { ModifyState } from './ModifyRes.js';
 import { RANGE_ERR, UPDATE } from './types.js';
 import { appendFixedValue } from './fixed.js';
+import { getByPath } from '@saulx/utils';
 const appendUpdate = (ctx, def, obj, res, overwrite) => {
     const err = modify(ctx, res, obj, def, UPDATE, def.tree, overwrite);
     if (err) {
@@ -13,6 +14,9 @@ const appendUpdate = (ctx, def, obj, res, overwrite) => {
     if (def.updateTs) {
         const updateTs = Date.now();
         for (const prop of def.updateTs) {
+            if (getByPath(obj, prop.path) !== undefined) {
+                continue;
+            }
             if (ctx.mergeMain) {
                 ctx.mergeMain.push(prop, updateTs);
                 ctx.mergeMainSize += prop.len + 4;
@@ -44,7 +48,7 @@ const appendUpdate = (ctx, def, obj, res, overwrite) => {
             ctx.buf[ctx.len++] = start >>>= 8;
             ctx.buf[ctx.len++] = len;
             ctx.buf[ctx.len++] = len >>>= 8;
-            const err = appendFixedValue(ctx, v, t);
+            const err = appendFixedValue(ctx, v, t, UPDATE);
             if (err) {
                 return err;
             }

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

@@ -238,7 +238,7 @@ const inspectObject = (object, q, path, level, isLast, isFirst, isObject, depth)
                     str += v;
                 }
             }
-            if (def?.typeIndex !== REFERENCE) {
+            if (def?.typeIndex !== REFERENCE && def?.typeIndex !== REFERENCES) {
                 str += ',\n';
             }
         }

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

@@ -3,6 +3,9 @@ import { ALIGNMENT_NOT_SET, EQUAL, MODE_AND_FIXED, MODE_DEFAULT, MODE_OR_FIXED,
 import { parseFilterValue } from './parseFilterValue.js';
 import { ENCODER } from '@saulx/utils';
 export const writeFixed = (prop, buf, value, size, offset) => {
+    if (prop.transform) {
+        value = prop.transform('filter', value);
+    }
     if (prop.typeIndex === BINARY || prop.typeIndex === STRING) {
         if (typeof value === 'string') {
             const { written } = ENCODER.encodeInto(value, buf.subarray(offset + 1));

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

@@ -1,5 +1,8 @@
 import { ALIGNMENT_NOT_SET, MODE_REFERENCE } from './types.js';
 export const createReferenceFilter = (prop, ctx, value) => {
+    if (prop.transform) {
+        value = prop.transform('filter', value);
+    }
     const isArray = Array.isArray(value);
     const len = isArray ? value.length : 1;
     const buf = new Uint8Array(11 + (isArray ? 8 : 0) + len * 4);

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

@@ -5,15 +5,17 @@ import { crc32 } from '../../crc32.js';
 import { ENCODER, concatUint8Arr } from '@saulx/utils';
 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') {
-        val = val.toLowerCase();
+    if (prop.transform) {
+        value = prop.transform('filter', value);
+    }
+    if (ctx.operation === HAS_TO_LOWER_CASE && typeof value === 'string') {
+        value = value.toLowerCase();
     }
     if (ctx.operation === LIKE && prop.typeIndex === VECTOR) {
-        if (!(val instanceof ArrayBuffer)) {
+        if (!(value instanceof ArrayBuffer)) {
             throw new Error('Vector should be an arrayBuffer');
         }
-        const vector = new Uint8Array(val);
+        const vector = new Uint8Array(value);
         let fn = new Uint8Array([getVectorFn(ctx.opts.fn)]);
         const score = ctx.opts.score
             ? new Uint8Array(new Float32Array([ctx.opts.score]).buffer)
@@ -23,41 +25,41 @@ const parseValue = (value, prop, ctx, lang) => {
         off += (buf.set(new Uint8Array(vector), off), vector.byteLength);
         off += (buf.set(fn, off), fn.byteLength);
         buf.set(score, off);
-        val = buf;
+        value = buf;
     }
-    if (val instanceof Uint8Array ||
+    if (value instanceof Uint8Array ||
         typeof value === 'string' ||
         !prop.separate ||
         ctx.operation !== EQUAL) {
-        if (typeof val === 'string') {
-            val = ENCODER.encode(val.normalize('NFKD'));
+        if (typeof value === 'string') {
+            value = ENCODER.encode(value.normalize('NFKD'));
         }
         if (prop.typeIndex === TEXT) {
             // 1 + size
             const fallbacksSize = lang.lang === 0 ? 0 : lang.fallback.length;
-            const tmp = new Uint8Array(val.byteLength + 2 + fallbacksSize);
-            tmp.set(val);
+            const tmp = new Uint8Array(value.byteLength + 2 + fallbacksSize);
+            tmp.set(value);
             tmp[tmp.byteLength - 1] = fallbacksSize;
             tmp[tmp.byteLength - 2] = lang.lang;
             for (let i = 0; i < fallbacksSize; i++) {
                 tmp[tmp.byteLength - 2 - fallbacksSize + i] = lang.fallback[i];
             }
-            val = tmp;
+            value = tmp;
         }
     }
-    if (val?.BYTES_PER_ELEMENT > 1) {
-        val = val.buffer;
+    if (value?.BYTES_PER_ELEMENT > 1) {
+        value = value.buffer;
     }
-    if (!(val instanceof Uint8Array || val instanceof ArrayBuffer)) {
+    if (!(value instanceof Uint8Array || value instanceof ArrayBuffer)) {
         throw new Error(`Incorrect value for filter: ${prop.path}`);
     }
     if (ctx.operation === LIKE && prop.typeIndex !== VECTOR) {
-        const tmp = new Uint8Array(val.byteLength + 1);
-        tmp.set(val instanceof ArrayBuffer ? new Uint8Array(val) : val);
+        const tmp = new Uint8Array(value.byteLength + 1);
+        tmp.set(value instanceof ArrayBuffer ? new Uint8Array(value) : value);
         tmp[tmp.byteLength - 1] = ctx.opts.score ?? 2;
-        val = tmp;
+        value = tmp;
     }
-    return val;
+    return value;
 };
 export const createVariableFilterBuffer = (value, prop, ctx, lang) => {
     let mode = MODE_DEFAULT_VAR;