@based/db 0.0.7 → 0.0.9

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

@@ -1,9 +1,9 @@
-import { createQueryDef, QueryDefType, includeFields, filter, sort, defToBuffer, getAll, filterOr, convertFilter, isAlias, } from './query.js';
+import { createQueryDef, QueryDefType, includeFields, filter, sort, defToBuffer, filterOr, convertFilter, isAlias, includeField, } from './query.js';
 import { BasedQueryResponse } from './BasedIterable.js';
 import { createOrGetEdgeRefQueryDef, createOrGetRefQueryDef, } from './include/utils.js';
 import { FilterBranch } from './filter/FilterBranch.js';
-import { search } from './search/index.js';
-import { isValidId, checkMaxIdsPerQuery, checkTotalBufferSize, hasField, hasFields, } from './validation.js';
+import { search, vectorSearch } from './search/index.js';
+import { isValidId, checkMaxIdsPerQuery, checkTotalBufferSize, hasField, isValidAlias, } from './validation.js';
 import native from '../../native.js';
 import { REFERENCE, REFERENCES } from '../../server/schema/types.js';
 import { subscribe } from './subscription/index.js';
@@ -21,13 +21,39 @@ export class QueryBranch {
         // @ts-ignore
         return this;
     }
-    filter(field, operator, value) {
-        const f = convertFilter(field, operator, value);
+    filter(field, operator, value, opts) {
+        const f = convertFilter(field, operator, value, opts);
         filter(this.db, this.def, f, this.def.filter);
         // @ts-ignore
         return this;
     }
-    search(query, ...fields) {
+    search(query, field, opts, ...fields) {
+        if (ArrayBuffer.isView(query)) {
+            // @ts-ignore
+            vectorSearch(this.def, query, field, opts ?? {});
+            // @ts-ignore
+            return this;
+        }
+        if (field) {
+            if (!fields) {
+                // @ts-ignore
+                fields = [field];
+            }
+            else {
+                // @ts-ignore
+                fields.unshift(field);
+            }
+        }
+        if (opts) {
+            if (!fields) {
+                // @ts-ignore
+                fields = [opts];
+            }
+            else {
+                // @ts-ignore
+                fields.unshift(opts);
+            }
+        }
         if (fields.length) {
             if (fields.length === 1) {
                 search(this.def, query, fields[0]);
@@ -61,14 +87,14 @@ export class QueryBranch {
         // @ts-ignore
         return this;
     }
-    or(field, operator, value) {
+    or(field, operator, value, opts) {
         if (typeof field === 'function') {
             const f = new FilterBranch(this.db, filterOr(this.db, this.def, [], this.def.filter), this.def);
             field(f);
             this.def.filter.size += f.filterBranch.size;
         }
         else {
-            const f = convertFilter(field, operator, value);
+            const f = convertFilter(field, operator, value, opts);
             filterOr(this.db, this.def, f, this.def.filter);
         }
         // @ts-ignore
@@ -83,13 +109,7 @@ export class QueryBranch {
     include(...fields) {
         for (const f of fields) {
             if (typeof f === 'string') {
-                if (f === '*') {
-                    hasFields(this.def.props);
-                    includeFields(this.def, getAll(this.def.props));
-                }
-                else {
-                    this.def.include.stringFields.add(f);
-                }
+                includeField(this.def, f);
             }
             else if (typeof f === 'function') {
                 f((field) => {
@@ -122,8 +142,8 @@ export class QueryBranch {
             else if (Array.isArray(f)) {
                 for (const field of f) {
                     hasField(field);
+                    includeField(this.def, field);
                 }
-                includeFields(this.def, f);
             }
             else if (f !== undefined) {
                 throw new Error('Invalid include statement: expected props, refs and edges (string or array) or function');
@@ -181,6 +201,9 @@ export class BasedDbQuery extends QueryBranch {
             }
         }
         const def = createQueryDef(db, QueryDefType.Root, target);
+        if (isAlias(id)) {
+            isValidAlias(def, id);
+        }
         super(db, def);
     }
     #getInternal = async (resolve, reject) => {

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

@@ -2,7 +2,7 @@ import { inspect } from 'node:util';
 import picocolors from 'picocolors';
 import { debug, resultToObject, readAllFields } from './query.js';
 import { size, time, inspectData } from './display.js';
-import { readUint32 } from '../bitWise.js';
+import { readFloatLE, readUint32 } from '../bitWise.js';
 export { time, size, inspectData };
 export class BasedQueryResponse {
     result;
@@ -70,8 +70,8 @@ export class BasedQueryResponse {
                 id,
             };
             if (this.def.search) {
-                item.$searchScore = result[i];
-                i += 1;
+                item.$searchScore = readFloatLE(result, i);
+                i += 4;
             }
             const l = readAllFields(this.def, result, i, result.byteLength - 4, item, id);
             i += l;

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

@@ -1,6 +1,6 @@
 import { DbClient } from '../../index.js';
 import { QueryDefFilter, QueryDef } from '../types.js';
-import { Operator } from './operators.js';
+import { FilterOpts, Operator } from './types.js';
 import { FilterBranchFn } from './types.js';
 export declare class FilterBranch {
     constructor(db: DbClient, filterBranch: QueryDefFilter, def: QueryDef);
@@ -8,6 +8,6 @@ export declare class FilterBranch {
     filterBranch: QueryDefFilter;
     def: QueryDef;
     or(fn: FilterBranchFn): FilterBranch;
-    or(field: string, operator?: Operator | boolean, value?: any): FilterBranch;
+    or(field: string, operator?: Operator | boolean, value?: any, opts?: FilterOpts): FilterBranch;
     filter(field: string, operator?: Operator | boolean, value?: any): this;
 }

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

@@ -8,14 +8,14 @@ export class FilterBranch {
     db;
     filterBranch;
     def;
-    or(field, operator, value) {
+    or(field, operator, value, opts) {
         if (typeof field === 'function') {
             const f = new FilterBranch(this.db, filterOr(this.db, this.def, [], this.filterBranch), this.def);
             field(f);
             this.def.filter.size += f.filterBranch.size;
         }
         else {
-            const f = convertFilter(field, operator, value);
+            const f = convertFilter(field, operator, value, opts);
             filterOr(this.db, this.def, f, this.filterBranch);
         }
         return this;

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

@@ -1,3 +1,4 @@
 import { PropDef, PropDefEdge } from '../../../server/schema/types.js';
-export declare const writeFixed: (prop: PropDef | PropDefEdge, buf: Buffer, value: any, size: number, offset: number, op: number) => void;
-export declare const createFixedFilterBuffer: (prop: PropDef | PropDefEdge, size: number, op: number, value: any, sort: boolean) => Buffer;
+import { FilterCtx } from './types.js';
+export declare const writeFixed: (prop: PropDef | PropDefEdge, buf: Buffer, value: any, size: number, offset: number) => void;
+export declare const createFixedFilterBuffer: (prop: PropDef | PropDefEdge, size: number, ctx: FilterCtx, value: any, sort: boolean) => Buffer;

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

@@ -1,6 +1,6 @@
 import { BINARY, STRING, REFERENCES, } from '../../../server/schema/types.js';
 import { propIsSigned } from '../../../server/schema/utils.js';
-import { negateType, stripNegation } from './operators.js';
+import { EQUAL, MODE_AND_FIXED, MODE_DEFAULT, MODE_OR_FIXED, } from './types.js';
 import { parseFilterValue } from './parseFilterValue.js';
 // -------------------------------------------
 // conditions normal
@@ -15,7 +15,7 @@ import { parseFilterValue } from './parseFilterValue.js';
 // field, [size 2]
 // [or = 2] [size 2] [start 2], [op], [size 2], value[size], [size 2], value[size]
 // -------------------------------------------
-export const writeFixed = (prop, buf, value, size, offset, op) => {
+export const writeFixed = (prop, buf, value, size, offset) => {
     if (prop.typeIndex === BINARY || prop.typeIndex === STRING) {
         if (typeof value === 'string') {
             const size = buf.write(value, offset + 1, 'utf8');
@@ -58,18 +58,21 @@ export const writeFixed = (prop, buf, value, size, offset, op) => {
 // default = 0,
 // orFixed = 1,
 // orVar = 2,
-export const createFixedFilterBuffer = (prop, size, op, value, sort) => {
+export const createFixedFilterBuffer = (prop, size, ctx, value, sort) => {
     let buf;
     const start = prop.start;
     if (Array.isArray(value)) {
         // [or = 1] [size 2] [start 2] [op], [repeat 2], value[size] value[size] value[size]
         const len = value.length;
         buf = Buffer.allocUnsafe(10 + len * size);
-        buf[0] = negateType(op);
-        buf[1] = prop.typeIndex === REFERENCES && op === 1 ? 3 : 1;
+        buf[0] = ctx.type;
+        buf[1] =
+            prop.typeIndex === REFERENCES && ctx.operation === EQUAL
+                ? MODE_AND_FIXED
+                : MODE_OR_FIXED;
         buf.writeUInt16LE(size, 2);
         buf.writeUInt16LE(start, 4);
-        buf[6] = stripNegation(op);
+        buf[6] = ctx.operation;
         buf[7] = prop.typeIndex;
         buf.writeUInt16LE(len, 8);
         if (sort) {
@@ -81,20 +84,20 @@ export const createFixedFilterBuffer = (prop, size, op, value, sort) => {
         }
         else {
             for (let i = 0; i < len; i++) {
-                writeFixed(prop, buf, parseFilterValue(prop, value[i]), size, 10 + i * size, op);
+                writeFixed(prop, buf, parseFilterValue(prop, value[i]), size, 10 + i * size);
             }
         }
     }
     else {
         // [or = 0] [size 2] [start 2], [op], value[size]
         buf = Buffer.allocUnsafe(8 + size);
-        buf[0] = negateType(op);
-        buf[1] = 0;
+        buf[0] = ctx.type;
+        buf[1] = MODE_DEFAULT;
         buf.writeUInt16LE(size, 2);
         buf.writeUInt16LE(start, 4);
-        buf[6] = stripNegation(op);
+        buf[6] = ctx.operation;
         buf[7] = prop.typeIndex;
-        writeFixed(prop, buf, parseFilterValue(prop, value), size, 8, op);
+        writeFixed(prop, buf, parseFilterValue(prop, value), size, 8);
     }
     return buf;
 };

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

@@ -1,2 +1,3 @@
 import { PropDef, PropDefEdge } from '../../../server/schema/types.js';
-export declare const createReferenceFilter: (prop: PropDef | PropDefEdge, op: number, value: any) => Buffer;
+import { FilterCtx } from './types.js';
+export declare const createReferenceFilter: (prop: PropDef | PropDefEdge, ctx: FilterCtx, value: any) => Buffer;

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

@@ -1,14 +1,15 @@
-import { negateType, stripNegation } from './operators.js';
-export const createReferenceFilter = (prop, op, value) => {
+import { MODE_REFERENCE } from './types.js';
+export const createReferenceFilter = (prop, ctx, value) => {
     let buf;
     const len = Array.isArray(value) ? value.length : 1;
     buf = Buffer.allocUnsafe(11 + len * 8);
-    buf[0] = negateType(op);
-    buf[1] = 5;
+    buf[0] = ctx.type;
+    buf[1] = MODE_REFERENCE;
     buf.writeUInt16LE(8, 2);
     buf.writeUInt16LE(len, 4);
-    buf[6] = stripNegation(op);
+    buf[6] = ctx.operation;
     buf[7] = prop.typeIndex;
+    // REF TYPE (only 1 exists now...)
     buf[8] = 0;
     buf.writeUInt16LE(prop.inverseTypeId, 9);
     if (Array.isArray(value)) {

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

@@ -1,3 +1,4 @@
 import { PropDef, PropDefEdge } from '../../../server/schema/types.js';
+import { FilterCtx } from './types.js';
 import { LangCode } from '@based/schema';
-export declare const createVariableFilterBuffer: (value: any, prop: PropDef | PropDefEdge, op: number, lang: LangCode) => Buffer;
+export declare const createVariableFilterBuffer: (value: any, prop: PropDef | PropDefEdge, ctx: FilterCtx, lang: LangCode) => Buffer;

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

@@ -1,15 +1,27 @@
-import { ALIAS, TEXT, } from '../../../server/schema/types.js';
-import { negateType, stripNegation } from './operators.js';
+import { ALIAS, TEXT, VECTOR, } from '../../../server/schema/types.js';
+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';
-const parseValue = (value, prop, op, lang) => {
+import { crc32 } from '../../crc32.js';
+const DEFAULT_SCORE = Buffer.from(new Float32Array([0.5]).buffer);
+const parseValue = (value, prop, ctx, lang) => {
     let val = value;
-    if (op === 19 && typeof val === 'string') {
+    if (ctx.operation === HAS_TO_LOWER_CASE && typeof val === 'string') {
         val = val.toLowerCase();
     }
+    if (ctx.operation === LIKE && prop.typeIndex === VECTOR) {
+        if (!(val instanceof ArrayBuffer)) {
+            throw new Error('Vector should be an arrayBuffer');
+        }
+        let fn = getVectorFn(ctx.opts.fn);
+        const score = ctx.opts.score
+            ? Buffer.from(new Float32Array([ctx.opts.score]).buffer)
+            : DEFAULT_SCORE;
+        val = Buffer.concat([Buffer.from(val), Buffer.from([fn]), score]);
+    }
     if (val instanceof Uint8Array ||
         typeof value === 'string' ||
         !prop.separate ||
-        op !== 1) {
+        ctx.operation !== EQUAL) {
         if (prop.typeIndex === TEXT) {
             // can be optmized replace when using uint8array
             val = Buffer.concat([Buffer.from(val), Buffer.from([lang])]);
@@ -18,21 +30,29 @@ const parseValue = (value, prop, op, lang) => {
             val = Buffer.from(val);
         }
     }
-    if (!(val instanceof Buffer)) {
-        throw new Error('Incorrect value for filter ' + prop.path);
+    if (val?.BYTES_PER_ELEMENT > 1) {
+        val = val.buffer;
+    }
+    if (!(val instanceof Buffer || val instanceof ArrayBuffer)) {
+        throw new Error(`Incorrect value for filter: ${prop.path}`);
+    }
+    if (ctx.operation === LIKE && prop.typeIndex !== VECTOR) {
+        // @ts-ignore
+        val = Buffer.concat([val, Buffer.from([ctx.opts.score ?? 2])]);
     }
+    // @ts-ignore TODO FDN-576
     return val;
 };
-export const createVariableFilterBuffer = (value, prop, op, lang) => {
-    let isOr = 4;
+export const createVariableFilterBuffer = (value, prop, ctx, lang) => {
+    let mode = MODE_DEFAULT_VAR;
     let val;
     let buf;
     if (Array.isArray(value)) {
-        if (op !== 1 || !prop.separate) {
-            isOr = 2;
+        if (ctx.operation !== EQUAL || !prop.separate) {
+            mode = MODE_OR_VAR;
             const x = [];
             for (const v of value) {
-                const a = parseValue(v, prop, op, lang);
+                const a = parseValue(v, prop, ctx, lang);
                 const size = Buffer.allocUnsafe(2);
                 size.writeUint16LE(a.byteLength);
                 x.push(size, a);
@@ -42,49 +62,60 @@ export const createVariableFilterBuffer = (value, prop, op, lang) => {
         else {
             const x = [];
             for (const v of value) {
-                x.push(parseValue(v, prop, op, lang));
+                x.push(parseValue(v, prop, ctx, lang));
             }
             val = x;
         }
     }
     else {
-        val = parseValue(value, prop, op, lang);
+        val = parseValue(value, prop, ctx, lang);
     }
-    // --------------------
-    if (op === 3 || op === 1 || op === 2 || op === 16 || op === 18 || op === 19) {
+    // -------------------- PUT VARIABLES HERE
+    if (ctx.operation === EQUAL ||
+        ctx.operation === HAS ||
+        ctx.operation === LIKE ||
+        ctx.operation === HAS_TO_LOWER_CASE) {
         if (prop.separate) {
-            if (op === 1 && prop.typeIndex !== ALIAS) {
-                // console.log('STRICT EQUAL FOR TEXT ALSO!')
-                // 17 crc32 check
-                buf = createFixedFilterBuffer(prop, 8, 17, val, false);
+            if (ctx.operation === EQUAL &&
+                prop.typeIndex !== ALIAS &&
+                prop.typeIndex !== VECTOR) {
+                if (prop.typeIndex === TEXT) {
+                    buf = writeVarFilter(mode, Buffer.concat([
+                        Buffer.from(new Uint32Array([crc32(val.slice(0, -1)), val.byteLength - 1])
+                            .buffer),
+                        Buffer.from(new Uint8Array([val[val.length - 1]]).buffer),
+                    ]), ctx, prop, 0, 0);
+                }
+                else {
+                    buf = createFixedFilterBuffer(prop, 8, { operation: EQUAL_CRC32, type: ctx.type, opts: ctx.opts }, val, false);
+                }
             }
             else {
-                buf = writeVarFilter(isOr, val, buf, op, prop, 0, 0);
+                buf = writeVarFilter(mode, val, ctx, prop, 0, 0);
             }
         }
         else {
-            // HANDLE EQUAL
-            buf = writeVarFilter(isOr, val, buf, op, prop, prop.start, prop.len);
+            buf = writeVarFilter(mode, val, ctx, prop, prop.start, prop.len);
         }
     }
     else {
-        console.log('OP NOT SUPPORTED YET =>', op);
+        console.log('OP NOT SUPPORTED YET =>', ctx);
     }
     return buf;
 };
-function writeVarFilter(isOr, val, buf, op, prop, start, len) {
+function writeVarFilter(mode, val, ctx, prop, start, len) {
     const size = val.byteLength;
-    buf = Buffer.allocUnsafe(12 + size);
-    buf[0] = negateType(op);
-    buf[1] = isOr;
+    const buf = Buffer.allocUnsafe(12 + size);
+    buf[0] = ctx.type;
+    buf[1] = mode;
     buf.writeUInt16LE(start, 2);
     buf.writeUint16LE(len, 4);
     buf.writeUint32LE(size, 6);
-    buf[10] = stripNegation(op);
+    buf[10] = ctx.operation;
     buf[11] = prop.typeIndex;
     // need to pas LANG FROM QUERY
     // need to set on 12 if TEXT
-    buf.set(val, 12);
+    buf.set(Buffer.from(val), 12);
     return buf;
 }
 //# sourceMappingURL=createVariableFilterBuffer.js.map

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

@@ -1,10 +1,10 @@
 import { QueryDef, QueryDefFilter } from '../types.js';
 import { SchemaTypeDef } from '../../../server/schema/schema.js';
-import { Operator } from './operators.js';
+import { FilterOpts, Operator } from './types.js';
 import { Filter, FilterAst } from './types.js';
 import { DbClient } from '../../index.js';
 export { Operator, Filter };
 export declare const filterRaw: (db: DbClient, filter: Filter, schema: SchemaTypeDef, conditions: QueryDefFilter, def: QueryDef) => number;
 export declare const filter: (db: DbClient, def: QueryDef, filterAst: FilterAst, conditions: QueryDefFilter) => void;
 export declare const filterOr: (db: DbClient, def: QueryDef, filterAst: FilterAst[], conditions: QueryDefFilter) => QueryDefFilter;
-export declare const convertFilter: (field: string, operator?: Operator | boolean, value?: any) => FilterAst;
+export declare const convertFilter: (field: string, operator?: Operator | boolean, value?: any, opts?: FilterOpts) => FilterAst;

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

@@ -1,16 +1,14 @@
 import { isPropDef, ID_FIELD_DEF, TEXT, } from '../../../server/schema/schema.js';
 import { primitiveFilter } from './primitiveFilter.js';
+import { toFilterCtx } from './types.js';
 import { IsFilter } from './types.js';
 import { hasField, checkOperator, checkValue } from '../validation.js';
 import { langCodesMap } from '@based/schema';
 const referencesFilter = (db, filter, schema, conditions, def) => {
-    const [fieldStr, operator, value] = filter;
+    const [fieldStr, ctx, value] = filter;
     var size = 0;
     const path = fieldStr.split('.');
     let t = schema.tree;
-    hasField(fieldStr);
-    checkOperator(operator);
-    checkValue(value, operator);
     for (let i = 0; i < path.length; i++) {
         const p = path[i];
         t = t[p];
@@ -45,18 +43,14 @@ const referencesFilter = (db, filter, schema, conditions, def) => {
                 conditions.references.set(t.prop, refConditions);
             }
             // more nested
-            size += filterRaw(db, [path.slice(i + 1).join('.'), operator, value], refConditions.schema, refConditions, def);
+            size += filterRaw(db, [path.slice(i + 1).join('.'), ctx, value], refConditions.schema, refConditions, def);
             return size;
         }
     }
-    console.error(`Querty: field "${fieldStr}" does not exist on type ${schema.type}`);
-    return size;
+    throw new Error(`Query: field "${fieldStr}" does not exist on type ${schema.type}`);
 };
 export const filterRaw = (db, filter, schema, conditions, def) => {
-    const [field, operator, value] = filter;
-    hasField(field); // Validates if the field is a non-empty string
-    checkOperator(operator); // Validates if the operator is valid
-    checkValue(value, operator); // Validates the value based on the operator
+    const field = filter[0];
     let fieldDef = schema.props[field];
     if (!fieldDef) {
         const s = field.split('.');
@@ -101,14 +95,14 @@ export const filterOr = (db, def, filterAst, conditions) => {
     conditions.size += conditions.or.size;
     return conditions.or;
 };
-function normalizeNeedle(s) {
+const normalizeNeedle = (s) => {
     return s
         .normalize('NFKD')
         .split('')
         .filter((ch) => ch.charCodeAt(0) <= 127)
         .join('');
-}
-export const convertFilter = (field, operator, value) => {
+};
+export const convertFilter = (field, operator, value, opts) => {
     if (operator === undefined) {
         operator = '=';
         value = true;
@@ -122,26 +116,37 @@ export const convertFilter = (field, operator, value) => {
     checkValue(value, operator);
     if (operator === '!..') {
         return [
-            [field, '>', value[1]],
-            [field, '<', value[0]],
+            [field, toFilterCtx('>', opts), value[1]],
+            [field, toFilterCtx('<', opts), value[0]],
         ];
     }
     else if (operator === '..') {
         return [
-            [field, '>', value[0]],
-            [field, '<', value[1]],
+            [field, toFilterCtx('>', opts), value[0]],
+            [field, toFilterCtx('<', opts), value[1]],
         ];
     }
     else {
         if (operator == 'like') {
-            if (value.normalize) {
+            if (value == null) {
+                throw new Error('Value is required');
+            }
+            if (value?.normalize) {
                 value = normalizeNeedle(value);
             }
-            else {
-                value = value.map(normalizeNeedle);
+            else if (Array.isArray(value)) {
+                if (value[0]?.normalize) {
+                    value = value.map(normalizeNeedle);
+                }
+                else if (value[0]?.BYTES_PER_ELEMENT > 1) {
+                    value = value.map((v) => v.buffer);
+                }
+            }
+            else if (value?.BYTES_PER_ELEMENT > 1) {
+                value = value.buffer;
             }
         }
-        return [[field, operator, value]];
+        return [[field, toFilterCtx(operator, opts), value]];
     }
 };
 //# sourceMappingURL=filter.js.map

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

@@ -1,5 +1,6 @@
-import { TIMESTAMP, CREATED, UPDATED, ENUM, BOOLEAN, STRING, BINARY, } from '../../../server/schema/types.js';
+import { TIMESTAMP, CREATED, UPDATED, ENUM, BOOLEAN, STRING, BINARY, TEXT, } from '../../../server/schema/types.js';
 import { crc32 } from '../../crc32.js';
+import { convertToTimestamp } from '../../timestamp.js';
 // -------------------------------------------
 // conditions normal
 // field, [size 2]
@@ -13,26 +14,10 @@ import { crc32 } from '../../crc32.js';
 // field, [size 2]
 // [or = 2] [size 2] [start 2], [op], [size 2], value[size], [size 2], value[size]
 // -------------------------------------------
-const timeToNumber = (ex) => {
-    if (ex === 's') {
-        return 1000;
-    }
-    if (ex === 'm') {
-        return 1000 * 60;
-    }
-    if (ex === 'h') {
-        return 1000 * 60 * 60;
-    }
-    if (ex === 'd') {
-        return 1000 * 60 * 60 * 24;
-    }
-    if (ex === 'y') {
-        return 31556952000;
-    }
-    return 1;
-};
 export const parseFilterValue = (prop, value) => {
-    if (prop.typeIndex === BINARY || prop.typeIndex === STRING) {
+    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);
@@ -48,51 +33,11 @@ export const parseFilterValue = (prop, value) => {
     else if (prop.typeIndex === TIMESTAMP ||
         prop.typeIndex === CREATED ||
         prop.typeIndex === UPDATED) {
-        if (value instanceof Date) {
-            return value.valueOf();
-        }
-        if (typeof value === 'string') {
-            if (value === 'now') {
-                return Date.now();
-            }
-            const y = value.replace(/([+-])/g, ' $1 ');
-            const arr = y.split(/ +/);
-            let newValue = 0;
-            let now;
-            let op = 1;
-            for (const seg of arr) {
-                if (seg === '-') {
-                    op = -1;
-                }
-                else if (seg === '+') {
-                    op = 1;
-                }
-                else {
-                    var v = 0;
-                    if (seg === 'now') {
-                        if (!now) {
-                            now = Date.now();
-                        }
-                        v = now;
-                    }
-                    else if (/[smhdy]$/.test(seg)) {
-                        const ex = seg[seg.length - 1];
-                        const number = parseInt(seg, 10);
-                        v = number * timeToNumber(ex);
-                    }
-                    else if (seg) {
-                        v = new Date(seg).valueOf();
-                    }
-                    if (op === -1) {
-                        newValue -= v;
-                    }
-                    else {
-                        newValue += v;
-                    }
-                }
-            }
-            return newValue;
+        const v = convertToTimestamp(value);
+        if (typeof v !== 'number') {
+            throw new Error(`Incorrect value for timestamp ${prop.path.join('.')}`);
         }
+        return v;
     }
     return value;
 };