@based/db 0.1.4 → 0.2.0

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

@@ -1,5 +1,5 @@
 import picocolors from 'picocolors';
-import { BINARY, CARDINALITY, NUMBER, REFERENCE, REFERENCES, STRING, TEXT, TIMESTAMP, } from '@based/schema/def';
+import { ALIAS, BINARY, CARDINALITY, NUMBER, REFERENCE, REFERENCES, STRING, TEXT, TIMESTAMP, } from '@based/schema/def';
 import { ENCODER } from '@based/utils';
 const decimals = (v) => ~~(v * 100) / 100;
 const sizeCalc = (size) => {
@@ -53,7 +53,7 @@ export const prettyPrintVal = (v, type) => {
             (isLarger ? picocolors.dim('... ') : '') +
             picocolors.italic(picocolors.dim(`${~~((v.byteLength / 1e3) * 100) / 100}kb`)));
     }
-    if (type === STRING || type === TEXT) {
+    if (type === STRING || type === TEXT || type === ALIAS) {
         if (v.length > 50) {
             const byteLength = ENCODER.encode(v).byteLength;
             const chars = picocolors.italic(picocolors.dim(`${~~((byteLength / 1e3) * 100) / 100}kb`));
@@ -62,11 +62,11 @@ export const prettyPrintVal = (v, type) => {
                     picocolors.dim('...') +
                     '" ' +
                     chars;
-            return `"${v}`;
         }
-        else {
-            return `"${v}"`;
+        if (type === ALIAS) {
+            return `"${v}" ${picocolors.italic(picocolors.dim('alias'))}`;
         }
+        return `"${v}"`;
     }
     if (type === CARDINALITY) {
         return `${picocolors.blue(v)} ${picocolors.italic(picocolors.dim('unique'))}`;
@@ -216,14 +216,20 @@ const inspectObject = (object, q, path, level, isLast, isFirst, isObject, depth)
                     str += prettyPrintVal(v, def.typeIndex);
                 }
             }
-            else if (def.typeIndex === STRING) {
+            else if (def.typeIndex === STRING || def.typeIndex === ALIAS) {
                 if (v === undefined) {
                     return '';
                 }
                 str += prettyPrintVal(v, def.typeIndex);
             }
             else if (def.typeIndex === CARDINALITY) {
-                str += prettyPrintVal(v, def.typeIndex);
+                if (typeof v === 'object' && v !== null) {
+                    str +=
+                        inspectObject(v, q, key, level + 2, false, false, true, depth) + '';
+                }
+                else {
+                    str += prettyPrintVal(v, def.typeIndex);
+                }
             }
             else if (def.typeIndex === TIMESTAMP) {
                 str += prettyPrintVal(v, def.typeIndex);
@@ -336,7 +342,7 @@ export const inspectData = (q, def, level, top, depth, hasId = false) => {
         str += '\n' + prefix + ']';
     }
     else {
-        str += ']';
+        str += ']' + '\n';
     }
     return str;
 };

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

@@ -1,7 +1,22 @@
 import { BINARY, STRING, REFERENCES, TIMESTAMP, } from '@based/schema/def';
-import { ALIGNMENT_NOT_SET, EQUAL, MODE_AND_FIXED, MODE_DEFAULT, MODE_OR_FIXED, } from './types.js';
+import { ALIGNMENT_NOT_SET, EQUAL, isNumerical, MODE_AND_FIXED, MODE_DEFAULT, MODE_OR_FIXED, } from './types.js';
 import { parseFilterValue } from './parseFilterValue.js';
 import { ENCODER, writeDoubleLE, writeInt64, writeUint16, writeUint32, } from '@based/utils';
+const isNowQuery = (prop, value, ctx) => {
+    return (prop.typeIndex === TIMESTAMP &&
+        typeof value === 'string' &&
+        value.includes('now') &&
+        isNumerical(ctx.operation));
+};
+const createNowMeta = (prop, parsedValue, ctx) => {
+    return {
+        byteIndex: 8,
+        offset: parsedValue - Date.now(),
+        resolvedByteIndex: 0,
+        ctx,
+        prop,
+    };
+};
 export const writeFixed = (prop, buf, value, size, offset) => {
     if (prop.typeIndex === BINARY || prop.typeIndex === STRING) {
         if (typeof value === 'string') {
@@ -43,42 +58,64 @@ export const createFixedFilterBuffer = (prop, size, ctx, value, sort) => {
     if (Array.isArray(value)) {
         const len = value.length;
         // Add 8 extra bytes for alignment
-        const buf = new Uint8Array(18 + len * size);
-        buf[0] = ctx.type;
-        buf[1] =
+        const buffer = new Uint8Array(18 + len * size);
+        const result = { buffer };
+        buffer[0] = ctx.type;
+        buffer[1] =
             prop.typeIndex === REFERENCES && ctx.operation === EQUAL
                 ? MODE_AND_FIXED
                 : MODE_OR_FIXED;
-        buf[2] = prop.typeIndex;
-        writeUint16(buf, size, 3);
-        writeUint16(buf, start, 5);
-        buf[7] = ctx.operation;
-        writeUint16(buf, len, 8);
-        buf[10] = ALIGNMENT_NOT_SET;
+        buffer[2] = prop.typeIndex;
+        writeUint16(buffer, size, 3);
+        writeUint16(buffer, start, 5);
+        buffer[7] = ctx.operation;
+        writeUint16(buffer, len, 8);
+        buffer[10] = ALIGNMENT_NOT_SET;
         if (sort) {
             value = new Uint32Array(value.map((v) => parseFilterValue(prop, v)));
             value.sort();
             for (let i = 0; i < len; i++) {
-                writeUint32(buf, value[i], 18 + i * size);
+                writeUint32(buffer, value[i], 18 + i * size);
             }
         }
         else {
             for (let i = 0; i < len; i++) {
-                writeFixed(prop, buf, parseFilterValue(prop, value[i]), size, 18 + i * size);
+                const parsedValue = parseFilterValue(prop, value[i]);
+                if (isNowQuery(prop, value, ctx)) {
+                    if (!result.subscriptionMeta) {
+                        result.subscriptionMeta = {};
+                    }
+                    if (!result.subscriptionMeta.now) {
+                        result.subscriptionMeta = { now: [] };
+                    }
+                    result.subscriptionMeta.now.push(createNowMeta(prop, parsedValue, ctx));
+                }
+                writeFixed(prop, buffer, parsedValue, size, 18 + i * size);
             }
         }
-        return buf;
+        return result;
     }
     else {
-        const buf = new Uint8Array(8 + size);
-        buf[0] = ctx.type;
-        buf[1] = MODE_DEFAULT;
-        buf[2] = prop.typeIndex;
-        writeUint16(buf, size, 3);
-        writeUint16(buf, start, 5);
-        buf[7] = ctx.operation;
-        writeFixed(prop, buf, parseFilterValue(prop, value), size, 8);
-        return buf;
+        const buffer = new Uint8Array(8 + size);
+        buffer[0] = ctx.type;
+        buffer[1] = MODE_DEFAULT;
+        buffer[2] = prop.typeIndex;
+        writeUint16(buffer, size, 3);
+        writeUint16(buffer, start, 5);
+        buffer[7] = ctx.operation;
+        const parsedValue = parseFilterValue(prop, value);
+        writeFixed(prop, buffer, parsedValue, size, 8);
+        if (isNowQuery(prop, value, ctx)) {
+            return {
+                buffer,
+                subscriptionMeta: {
+                    now: [createNowMeta(prop, parsedValue, ctx)],
+                },
+            };
+        }
+        else {
+            return { buffer };
+        }
     }
 };
 //# sourceMappingURL=createFixedFilterBuffer.js.map

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

@@ -3,24 +3,24 @@ import { writeUint16, writeUint32 } from '@based/utils';
 export const createReferenceFilter = (prop, ctx, value) => {
     const isArray = Array.isArray(value);
     const len = isArray ? value.length : 1;
-    const buf = new Uint8Array(11 + (isArray ? 8 : 0) + len * 4);
-    buf[0] = ctx.type;
-    buf[1] = MODE_REFERENCE;
-    buf[2] = prop.typeIndex;
-    writeUint16(buf, 4, 3); // size (4)
-    writeUint16(buf, len, 5);
-    buf[7] = ctx.operation;
-    buf[8] = 0;
-    writeUint16(buf, prop.inverseTypeId, 9);
+    const buffer = new Uint8Array(11 + (isArray ? 8 : 0) + len * 4);
+    buffer[0] = ctx.type;
+    buffer[1] = MODE_REFERENCE;
+    buffer[2] = prop.typeIndex;
+    writeUint16(buffer, 4, 3); // size (4)
+    writeUint16(buffer, len, 5);
+    buffer[7] = ctx.operation;
+    buffer[8] = 0;
+    writeUint16(buffer, prop.inverseTypeId, 9);
     if (isArray) {
-        buf[11] = ALIGNMENT_NOT_SET;
+        buffer[11] = ALIGNMENT_NOT_SET;
         for (let i = 0; i < len; i++) {
-            writeUint32(buf, value[i], 19 + i * 4);
+            writeUint32(buffer, value[i], 19 + i * 4);
         }
     }
     else {
-        writeUint32(buf, value, 11);
+        writeUint32(buffer, value, 11);
     }
-    return buf;
+    return { buffer };
 };
 //# sourceMappingURL=createReferenceFilter.js.map

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

@@ -103,13 +103,14 @@ export const createVariableFilterBuffer = (value, prop, ctx, lang) => {
                     for (let i = 0; i < fbLen; i++) {
                         v[v.byteLength - (i + 1)] = val[val.byteLength - (i + 1)];
                     }
-                    parsedCondition = writeVarFilter(mode, v, ctx, prop, 0, 0);
+                    parsedCondition = { buffer: writeVarFilter(mode, v, ctx, prop, 0, 0) };
                 }
                 else {
                     parsedCondition = createFixedFilterBuffer(prop, 8, {
                         operation: EQUAL_CRC32,
                         type: ctx.type,
                         opts: ctx.opts,
+                        typeId: ctx.typeId,
                     }, val, false);
                 }
             }
@@ -117,11 +118,13 @@ export const createVariableFilterBuffer = (value, prop, ctx, lang) => {
                 if (val instanceof ArrayBuffer) {
                     val = new Uint8Array(val);
                 }
-                parsedCondition = writeVarFilter(mode, val, ctx, prop, 0, 0);
+                parsedCondition = { buffer: writeVarFilter(mode, val, ctx, prop, 0, 0) };
             }
         }
         else {
-            parsedCondition = writeVarFilter(mode, val, ctx, prop, prop.start, prop.len);
+            parsedCondition = {
+                buffer: writeVarFilter(mode, val, ctx, prop, prop.start, prop.len),
+            };
         }
     }
     return parsedCondition;

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

@@ -47,11 +47,15 @@ const referencesFilter = (db, filter, schema, conditions, def) => {
                     fromRef: t,
                     schema,
                     size: 0,
+                    hasSubMeta: false,
                 };
                 conditions.references.set(t.prop, refConditions);
             }
             // more nested
             size += filterRaw(db, [path.slice(i + 1).join('.'), ctx, value], refConditions.schema, refConditions, def);
+            if (refConditions.hasSubMeta) {
+                conditions.hasSubMeta = true;
+            }
             return size;
         }
     }
@@ -108,6 +112,7 @@ export const filterOr = (db, def, filterAst, conditions) => {
         conditions.or = {
             size: 0,
             conditions: new Map(),
+            hasSubMeta: false,
         };
     }
     else {
@@ -117,6 +122,9 @@ export const filterOr = (db, def, filterAst, conditions) => {
     }
     filter(db, def, filterAst, conditions.or);
     conditions.size += conditions.or.size;
+    if (conditions.or.hasSubMeta) {
+        conditions.hasSubMeta = true;
+    }
     return conditions.or;
 };
 //# sourceMappingURL=filter.js.map

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

@@ -53,7 +53,10 @@ export const primitiveFilter = (def, prop, filter, conditions, lang) => {
         arr = [];
         bufferMap.set(fieldIndexChar, arr);
     }
-    size += parsedCondition.byteLength;
+    size += parsedCondition.buffer.byteLength;
+    if ('subscriptionMeta' in parsedCondition) {
+        conditions.hasSubMeta = true;
+    }
     arr.push(parsedCondition);
     return size;
 };

package/dist/src/client/query/filter/{toBuffer.d.ts → toByteCode.d.ts}

@@ -1,4 +1,5 @@
 import { QueryDefFilter } from '../types.js';
-export declare const fillConditionsBuffer: (result: Uint8Array, conditions: QueryDefFilter, offset: number) => number;
+export declare const fillConditionsBuffer: (result: Uint8Array, conditions: QueryDefFilter, offset: number, metaOffset: number) => number;
 export declare const isSimpleMainFilter: (conditions: QueryDefFilter) => boolean;
-export declare const filterToBuffer: (conditions: QueryDefFilter) => Uint8Array;
+export declare const filterToBuffer: (conditions: QueryDefFilter, metaOffset: number) => Uint8Array;
+export declare const resolveMetaIndexes: (defFilter: QueryDefFilter, offset: number) => void;

package/dist/src/client/query/filter/{toBuffer.js → toByteCode.js}

@@ -1,6 +1,6 @@
 import { writeUint16, writeUint32 } from '@based/utils';
 import { META_EDGE, META_EXISTS, META_OR_BRANCH, META_REFERENCE, TYPE_DEFAULT, TYPE_NEGATE, } from './types.js';
-const writeConditions = (result, k, offset, conditions) => {
+const writeConditions = (result, k, offset, conditions, metaOffset) => {
     let lastWritten = offset;
     result[lastWritten] = k;
     lastWritten++;
@@ -8,14 +8,21 @@ const writeConditions = (result, k, offset, conditions) => {
     lastWritten += 2;
     let conditionSize = 0;
     for (const condition of conditions) {
-        conditionSize += condition.byteLength;
-        result.set(condition, lastWritten);
-        lastWritten += condition.byteLength;
+        conditionSize += condition.buffer.byteLength;
+        result.set(condition.buffer, lastWritten);
+        if ('subscriptionMeta' in condition) {
+            if ('now' in condition.subscriptionMeta) {
+                for (const n of condition.subscriptionMeta.now) {
+                    n.resolvedByteIndex = n.byteIndex + lastWritten + metaOffset;
+                }
+            }
+        }
+        lastWritten += condition.buffer.byteLength;
     }
     writeUint16(result, conditionSize, sizeIndex);
     return lastWritten - offset;
 };
-export const fillConditionsBuffer = (result, conditions, offset) => {
+export const fillConditionsBuffer = (result, conditions, offset, metaOffset) => {
     let lastWritten = offset;
     let orJumpIndex = 0;
     if (conditions.or && conditions.or.size != 0) {
@@ -26,7 +33,7 @@ export const fillConditionsBuffer = (result, conditions, offset) => {
         lastWritten += 4;
     }
     conditions.conditions.forEach((v, k) => {
-        lastWritten += writeConditions(result, k, lastWritten, v);
+        lastWritten += writeConditions(result, k, lastWritten, v, metaOffset);
     });
     if (conditions.references) {
         for (const [refField, refConditions] of conditions.references) {
@@ -38,7 +45,7 @@ export const fillConditionsBuffer = (result, conditions, offset) => {
             lastWritten += 2;
             const sizeIndex = lastWritten;
             lastWritten += 2;
-            const size = fillConditionsBuffer(result, refConditions, lastWritten);
+            const size = fillConditionsBuffer(result, refConditions, lastWritten, metaOffset);
             writeUint16(result, size, sizeIndex);
             lastWritten += size;
         }
@@ -49,13 +56,13 @@ export const fillConditionsBuffer = (result, conditions, offset) => {
             lastWritten++;
             let sizeIndex = lastWritten;
             lastWritten += 2;
-            const size = writeConditions(result, k, lastWritten, v);
+            const size = writeConditions(result, k, lastWritten, v, metaOffset);
             lastWritten += size;
             writeUint16(result, size, sizeIndex);
         });
     }
     if (conditions.or && conditions.or.size != 0) {
-        const size = fillConditionsBuffer(result, conditions.or, lastWritten);
+        const size = fillConditionsBuffer(result, conditions.or, lastWritten, metaOffset);
         writeUint16(result, size, orJumpIndex);
         writeUint32(result, lastWritten, orJumpIndex + 2);
         lastWritten += size;
@@ -85,16 +92,43 @@ export const isSimpleMainFilter = (conditions) => {
     }
     return false;
 };
-export const filterToBuffer = (conditions) => {
+export const filterToBuffer = (conditions, metaOffset) => {
     // add extra byte IS SINGLE CONDITION
     let result;
     if (conditions.size > 0) {
         result = new Uint8Array(conditions.size);
-        fillConditionsBuffer(result, conditions, 0);
+        fillConditionsBuffer(result, conditions, 0, metaOffset);
     }
     else {
         result = new Uint8Array(0);
     }
     return result;
 };
-//# sourceMappingURL=toBuffer.js.map
+export const resolveMetaIndexes = (defFilter, offset) => {
+    if (!defFilter.hasSubMeta) {
+        return;
+    }
+    for (const conditions of defFilter.conditions.values()) {
+        for (const condition of conditions) {
+            if (condition.subscriptionMeta) {
+                if (condition.subscriptionMeta.now) {
+                    for (const now of condition.subscriptionMeta.now) {
+                        now.resolvedByteIndex += offset;
+                    }
+                }
+            }
+        }
+    }
+    if (defFilter.and) {
+        resolveMetaIndexes(defFilter.and, offset);
+    }
+    if (defFilter.or) {
+        resolveMetaIndexes(defFilter.or, offset);
+    }
+    if (defFilter.references) {
+        for (const ref of defFilter.references.values()) {
+            resolveMetaIndexes(ref, offset);
+        }
+    }
+};
+//# sourceMappingURL=toByteCode.js.map

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

@@ -49,6 +49,7 @@ export type FilterCtx = {
     operation: OPERATOR;
     type: FILTER_TYPE;
     opts: FilterOpts;
+    typeId: number;
 };
 export declare const VECTOR_DOT_PRODUCT = 0;
 export declare const VECTOR_MANHATTAN_DIST = 1;

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

@@ -90,6 +90,7 @@ export const toFilterCtx = (def, op, opts = {}) => {
             operation: EQUAL,
             type: op === '!=' ? TYPE_NEGATE : TYPE_DEFAULT,
             opts,
+            typeId: def.schema.id,
         };
     }
     if (op === 'exists' || op === '!exists') {
@@ -97,6 +98,7 @@ export const toFilterCtx = (def, op, opts = {}) => {
             operation: EXISTS,
             type: op === '!exists' ? TYPE_NEGATE : TYPE_DEFAULT,
             opts,
+            typeId: def.schema.id,
         };
     }
     if (op === 'includes' || op === '!includes') {
@@ -104,22 +106,48 @@ export const toFilterCtx = (def, op, opts = {}) => {
             operation: opts.lowerCase ? INCLUDES_TO_LOWER_CASE : INCLUDES,
             type: op === '!includes' ? TYPE_NEGATE : TYPE_DEFAULT,
             opts,
+            typeId: def.schema.id,
         };
     }
     if (op === '>') {
-        return { operation: GREATER_THAN, opts, type: TYPE_DEFAULT };
+        return {
+            operation: GREATER_THAN,
+            opts,
+            type: TYPE_DEFAULT,
+            typeId: def.schema.id,
+        };
     }
     if (op === '<') {
-        return { operation: SMALLER_THAN, opts, type: TYPE_DEFAULT };
+        return {
+            operation: SMALLER_THAN,
+            opts,
+            type: TYPE_DEFAULT,
+            typeId: def.schema.id,
+        };
     }
     if (op === '>=') {
-        return { operation: GREATER_THAN_INCLUSIVE, opts, type: TYPE_DEFAULT };
+        return {
+            operation: GREATER_THAN_INCLUSIVE,
+            opts,
+            type: TYPE_DEFAULT,
+            typeId: def.schema.id,
+        };
     }
     if (op === '<=') {
-        return { operation: SMALLER_THAN_INCLUSIVE, opts, type: TYPE_DEFAULT };
+        return {
+            operation: SMALLER_THAN_INCLUSIVE,
+            opts,
+            type: TYPE_DEFAULT,
+            typeId: def.schema.id,
+        };
     }
     if (op === 'like') {
-        return { operation: LIKE, opts, type: TYPE_DEFAULT };
+        return {
+            operation: LIKE,
+            opts,
+            type: TYPE_DEFAULT,
+            typeId: def.schema.id,
+        };
     }
     filterOperatorDoesNotExist(def, op);
 };

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

@@ -1,3 +1,3 @@
 import { DbClient } from '../../index.js';
-import { QueryDef } from '../types.js';
-export declare const includeToBuffer: (db: DbClient, def: QueryDef) => Uint8Array[];
+import { IntermediateByteCode, QueryDef } from '../types.js';
+export declare const includeToBuffer: (db: DbClient, def: QueryDef) => IntermediateByteCode[];

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

@@ -1,5 +1,5 @@
 import { MICRO_BUFFER, STRING, TEXT, JSON, BINARY } from '@based/schema/def';
-import { QueryDefType } from '../types.js';
+import { QueryDefType, } from '../types.js';
 import { walkDefs } from './walk.js';
 import { langCodesMap } from '@based/schema';
 import { writeUint32 } from '@based/utils';

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

@@ -4,7 +4,7 @@ export * from './include/props.js';
 export * from './include/toByteCode.js';
 export * from './toByteCode/toByteCode.js';
 export * from './filter/filter.js';
-export * from './filter/toBuffer.js';
+export * from './filter/toByteCode.js';
 export * from './sort.js';
 export * from './debug.js';
 export * from './aggregates/aggregation.js';

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

@@ -4,7 +4,7 @@ export * from './include/props.js';
 export * from './include/toByteCode.js';
 export * from './toByteCode/toByteCode.js';
 export * from './filter/filter.js';
-export * from './filter/toBuffer.js';
+export * from './filter/toByteCode.js';
 export * from './sort.js';
 export * from './debug.js';
 export * from './aggregates/aggregation.js';

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

@@ -1,12 +1,12 @@
 import { langCodesMap } from '@based/schema';
 import { DEF_RANGE_PROP_LIMIT, DEF_RANGE_REF_LIMIT } from './thresholds.js';
-import { QueryDefType, } from './types.js';
+import { QueryDefType, QueryType, } from './types.js';
 import { validateAlias, validateId, validateIds, validateType, } from './validation.js';
 const createEmptySharedDef = (skipValidation) => {
     const q = {
         errors: [],
         skipValidation,
-        filter: { conditions: new Map(), size: 0 },
+        filter: { conditions: new Map(), size: 0, hasSubMeta: false },
         range: { offset: 0, limit: 0 },
         lang: {
             lang: langCodesMap.get('none'),
@@ -46,15 +46,19 @@ export function createQueryDef(db, type, target, skipValidation) {
         if (type === QueryDefType.Root) {
             if (t.id) {
                 t.id = validateId(q, t.id);
+                q.queryType = QueryType.id;
             }
             else if (t.ids) {
+                q.queryType = QueryType.ids;
                 t.ids = validateIds(q, t.ids);
                 q.range.limit = t.ids.length;
             }
             else if (t.alias) {
+                q.queryType = QueryType.alias;
                 t.resolvedAlias = validateAlias(q, t.alias);
             }
             else {
+                q.queryType = QueryType.default;
                 q.range.limit = DEF_RANGE_PROP_LIMIT;
             }
         }

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

@@ -1,13 +1,11 @@
-import native from '../../native.js';
-import { concatUint8Arr } from '@based/utils';
-import { defToBuffer } from './toByteCode/toByteCode.js';
+import { queryToBuffer } from './toByteCode/toByteCode.js';
 import { handleErrors } from './validation.js';
 import { createQueryDef } from './queryDef.js';
 import { QueryDefType } from './types.js';
 import { includeField } from './query.js';
 import { convertToReaderSchema } from './queryDefToReadSchema.js';
 export const registerQuery = (q) => {
-    if (!q.id) {
+    if (!q.buffer) {
         const commands = q.queryCommands;
         q.queryCommands = null;
         const def = createQueryDef(q.db, QueryDefType.Root, 
@@ -22,16 +20,14 @@ export const registerQuery = (q) => {
             includeField(q.def, { field: '*' });
         }
         q.queryCommands = commands;
-        const b = defToBuffer(q.db, q.def);
-        const buf = concatUint8Arr(b);
-        let id = native.crc32(buf);
-        q.id = id;
-        def.queryId = q.id;
+        const buf = queryToBuffer(q);
         q.buffer = buf;
+        // console.log(buf)
         // console.log('--------------------------------------------------')
         // console.dir(convertToReaderSchema(q.def), { depth: 100 })
         // const c = convertToReaderSchema(q.def)
         // const s = serialize(c)
+        // console.log('--------------------------------------------------')
         // console.log(deSerializeSchema(s))
         // q.def.readSchema = deSerializeSchema(
         //   serialize(convertToReaderSchema(q.def)),

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

@@ -1,5 +1,8 @@
 import { BasedQueryResponse } from '../BasedQueryResponse.js';
 import { registerQuery } from '../registerQuery.js';
+import { registerSubscription } from './toByteCode.js';
+// exec
+// subscription thing
 export class SubStore {
     listeners;
     onClose;
@@ -38,6 +41,7 @@ export class SubStore {
                 if (!killed) {
                     try {
                         registerQuery(q);
+                        registerSubscription(q);
                         this.onClose = q.db.hooks.subscribe(q, onData, onError);
                     }
                     catch (err) {
@@ -55,6 +59,7 @@ export class SubStore {
         else {
             try {
                 registerQuery(q);
+                registerSubscription(q);
                 this.onClose = q.db.hooks.subscribe(q, onData, onError);
             }
             catch (err) {

package/dist/src/client/query/subscription/toByteCode.d.ts

@@ -0,0 +1,6 @@
+import { BasedDbQuery } from '../BasedDbQuery.js';
+import { FilterMetaNow, QueryDef, QueryDefFilter } from '../types.js';
+export declare const collectFilters: (filter: QueryDefFilter, fields?: Set<number>, nowQueries?: FilterMetaNow[]) => FilterMetaNow[];
+export declare const collectFields: (def: QueryDef) => Set<number>;
+export declare const collectTypes: (def: QueryDef | QueryDefFilter, types?: Set<number>) => Set<number>;
+export declare const registerSubscription: (query: BasedDbQuery) => void;