@based/db 0.1.5 → 0.2.0

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

@@ -1,16 +1,26 @@
 import { createSortBuffer } from '../sort.js';
-import { QueryDefType, QueryType } from '../types.js';
+import { QueryDefType, } from '../types.js';
 import { includeToBuffer } from '../include/toByteCode.js';
-import { filterToBuffer } from '../query.js';
 import { searchToBuffer } from '../search/index.js';
-import { ENCODER, writeUint64 } from '@based/utils';
-import { aggregateToBuffer, isRootCountOnly, } from '../aggregates/aggregation.js';
+import { writeUint64 } from '@based/utils';
 import { defaultQuery } from './default.js';
+import { idQuery } from './id.js';
+import { aliasQuery } from './alias.js';
+import { idsQuery } from './ids.js';
+import { referencesQuery } from './references.js';
+import { referenceQuery } from './reference.js';
+import { aggregatesQuery } from './aggregates.js';
+import { resolveMetaIndexes } from '../query.js';
 const byteSize = (arr) => {
     return arr.reduce((a, b) => {
-        return a + b.byteLength;
+        return a + b.buffer.byteLength;
     }, 0);
 };
+const schemaChecksum = (def) => {
+    const checksum = new Uint8Array(8);
+    writeUint64(checksum, def.schemaChecksum ?? 0, 0);
+    return { buffer: checksum, def };
+};
 export function defToBuffer(db, def) {
     const result = [];
     const include = includeToBuffer(db, def);
@@ -34,211 +44,52 @@ export function defToBuffer(db, def) {
     }
     const size = (edges ? edgesSize + 3 : 0) + byteSize(include);
     if (def.aggregate) {
-        const aggregateSize = def.aggregate.size || 0;
-        if (aggregateSize === 0) {
-            throw new Error('Wrong aggregate size (0)');
-        }
-        const filterSize = def.filter.size || 0;
-        if (def.type === QueryDefType.References) {
-            const buf = new Uint8Array(13 + filterSize + aggregateSize);
-            const sz = 10 + filterSize + aggregateSize;
-            buf[0] = 2 /* includeOp.REFERENCES_AGGREGATION */;
-            buf[1] = sz;
-            buf[2] = sz >>> 8;
-            buf[3] = filterSize;
-            buf[4] = filterSize >>> 8;
-            buf[5] = def.range.offset;
-            buf[6] = def.range.offset >>> 8;
-            buf[7] = def.range.offset >>> 16;
-            buf[8] = def.range.offset >>> 24;
-            if (filterSize) {
-                buf.set(filterToBuffer(def.filter), 9);
-            }
-            // required to get typeEntry and fieldSchema
-            buf[9 + filterSize] = def.schema.idUint8[0]; // typeId
-            buf[9 + 1 + filterSize] = def.schema.idUint8[1]; // typeId
-            buf[9 + 2 + filterSize] = def.target.propDef.prop; // refField
-            const aggregateBuffer = aggregateToBuffer(def.aggregate);
-            buf.set(aggregateBuffer, 9 + 3 + filterSize);
-            result.push(buf);
-        }
-        else {
-            const buf = new Uint8Array(16 + filterSize + aggregateSize);
-            buf[0] = isRootCountOnly(def, filterSize)
-                ? QueryType.aggregatesCountType
-                : QueryType.aggregates;
-            buf[1] = def.schema.idUint8[0];
-            buf[2] = def.schema.idUint8[1];
-            buf[3] = def.range.offset;
-            buf[4] = def.range.offset >>> 8;
-            buf[5] = def.range.offset >>> 16;
-            buf[6] = def.range.offset >>> 24;
-            buf[7] = def.range.limit;
-            buf[8] = def.range.limit >>> 8;
-            buf[9] = def.range.limit >>> 16;
-            buf[10] = def.range.limit >>> 24;
-            buf[11] = filterSize;
-            buf[12] = filterSize >>> 8;
-            if (filterSize) {
-                buf.set(filterToBuffer(def.filter), 13);
-            }
-            const aggregateBuffer = aggregateToBuffer(def.aggregate);
-            buf[14 + filterSize] = aggregateSize;
-            buf[15 + filterSize] = aggregateSize >>> 8;
-            buf.set(aggregateBuffer, 16 + filterSize);
-            result.push(buf);
-        }
+        result.push(aggregatesQuery(def));
         if (def.type === QueryDefType.Root) {
-            const checksum = new Uint8Array(8);
-            writeUint64(checksum, def.schemaChecksum ?? 0, 0);
-            result.push(checksum);
+            result.push(schemaChecksum(def));
         }
         return result;
     }
     if (def.type === QueryDefType.Root) {
-        let search;
-        let searchSize = 0;
-        const filterSize = def.filter.size || 0;
-        if (def.search) {
-            search = searchToBuffer(def.search);
-            searchSize = def.search.size;
-        }
         if (def.target.resolvedAlias) {
-            const alias = def.target.resolvedAlias;
-            const aliasStr = ENCODER.encode(alias.value);
-            const aliasLen = aliasStr.byteLength;
-            const buf = new Uint8Array(8 + filterSize + aliasLen);
-            buf[0] = QueryType.alias;
-            buf[1] = def.schema.idUint8[0];
-            buf[2] = def.schema.idUint8[1];
-            buf[3] = alias.def.prop;
-            buf[4] = aliasLen;
-            buf[5] = aliasLen >>> 8;
-            buf.set(aliasStr, 6);
-            buf[6 + aliasLen] = filterSize;
-            buf[7 + aliasLen] = filterSize >>> 8;
-            if (filterSize) {
-                buf.set(filterToBuffer(def.filter), 8 + aliasLen);
-            }
-            result.push(buf);
+            result.push(aliasQuery(def));
         }
         else if (typeof def.target.id === 'number') {
-            const buf = new Uint8Array(9 + filterSize);
-            buf[0] = QueryType.id;
-            buf[1] = def.schema.idUint8[0];
-            buf[2] = def.schema.idUint8[1];
-            buf[3] = def.target.id;
-            buf[4] = def.target.id >>> 8;
-            buf[5] = def.target.id >>> 16;
-            buf[6] = def.target.id >>> 24;
-            buf[7] = filterSize;
-            buf[8] = filterSize >>> 8;
-            if (filterSize) {
-                buf.set(filterToBuffer(def.filter), 9);
-            }
-            result.push(buf);
+            result.push(idQuery(def));
         }
         else {
-            let sort;
-            let sortSize = 0;
-            if (def.sort) {
-                sort = createSortBuffer(def.sort);
-                sortSize = sort.byteLength;
-            }
             if (def.target.ids) {
+                const sortSize = def.sort ? createSortBuffer(def.sort).byteLength : 0;
                 if (!sortSize &&
                     (def.range.offset || def.range.limit < def.target.ids.length)) {
+                    ;
                     def.target.ids = def.target.ids.slice(def.range.offset, def.range.offset + def.range.limit);
                 }
-                const idsSize = def.target.ids.length * 4;
-                const buf = new Uint8Array(21 + idsSize + filterSize + sortSize + searchSize);
-                buf[0] = QueryType.ids;
-                buf[1] = def.schema.idUint8[0];
-                buf[2] = def.schema.idUint8[1];
-                buf[3] = idsSize;
-                buf[4] = idsSize >>> 8;
-                buf[5] = idsSize >>> 16;
-                buf[6] = idsSize >>> 24;
-                buf.set(new Uint8Array(def.target.ids.buffer), 7);
-                buf[idsSize + 7] = def.range.offset;
-                buf[idsSize + 8] = def.range.offset >>> 8;
-                buf[idsSize + 9] = def.range.offset >>> 16;
-                buf[idsSize + 10] = def.range.offset >>> 24;
-                buf[idsSize + 11] = def.range.limit;
-                buf[idsSize + 12] = def.range.limit >>> 8;
-                buf[idsSize + 13] = def.range.limit >>> 16;
-                buf[idsSize + 14] = def.range.limit >>> 24;
-                // if (filterSize && isSimpleMainFilter(def.filter)) {
-                buf[idsSize + 15] = filterSize;
-                buf[idsSize + 16] = filterSize >>> 8;
-                if (filterSize) {
-                    // just write it here dont do set
-                    buf.set(filterToBuffer(def.filter), idsSize + 17);
-                }
-                buf[17 + filterSize + idsSize] = sortSize;
-                buf[18 + filterSize + idsSize] = sortSize >>> 8;
-                if (sortSize) {
-                    buf.set(sort, 19 + filterSize + idsSize);
-                }
-                buf[19 + filterSize + idsSize + sortSize] = searchSize;
-                buf[20 + filterSize + idsSize + sortSize] = searchSize >>> 8;
-                if (searchSize) {
-                    buf.set(search, 21 + filterSize + idsSize + sortSize);
-                }
-                // ----------
-                result.push(buf);
+                result.push(idsQuery(def));
             }
             else {
+                let search;
+                let searchSize = 0;
+                if (def.search) {
+                    search = searchToBuffer(def.search);
+                    searchSize = def.search.size;
+                }
+                let sort;
+                let sortSize = 0;
+                if (def.sort) {
+                    sort = createSortBuffer(def.sort);
+                    sortSize = sort.byteLength;
+                }
+                const filterSize = def.filter.size || 0;
                 result.push(defaultQuery(def, filterSize, sortSize, searchSize, sort, search));
             }
         }
     }
     else if (def.type === QueryDefType.References) {
-        const filterSize = def.filter.size || 0;
-        let sort;
-        if (def.sort) {
-            sort = createSortBuffer(def.sort);
-        }
-        const sortSize = sort?.byteLength ?? 0;
-        const modsSize = filterSize + sortSize;
-        const meta = new Uint8Array(modsSize + 10 + 8);
-        const sz = size + 7 + modsSize + 8;
-        meta[0] = 4 /* includeOp.REFERENCES */;
-        meta[1] = sz;
-        meta[2] = sz >>> 8;
-        meta[3] = filterSize;
-        meta[4] = filterSize >>> 8;
-        meta[5] = sortSize;
-        meta[6] = sortSize >>> 8;
-        meta[7] = def.range.offset;
-        meta[8] = def.range.offset >>> 8;
-        meta[9] = def.range.offset >>> 16;
-        meta[10] = def.range.offset >>> 24;
-        meta[11] = def.range.limit;
-        meta[12] = def.range.limit >>> 8;
-        meta[13] = def.range.limit >>> 16;
-        meta[14] = def.range.limit >>> 24;
-        if (filterSize) {
-            meta.set(filterToBuffer(def.filter), 15);
-        }
-        if (sort) {
-            meta.set(sort, 15 + filterSize);
-        }
-        meta[15 + modsSize] = def.schema.idUint8[0];
-        meta[15 + 1 + modsSize] = def.schema.idUint8[1];
-        meta[15 + 2 + modsSize] = def.target.propDef.prop;
-        result.push(meta);
+        result.push(referencesQuery(def, size));
     }
     else if (def.type === QueryDefType.Reference) {
-        const meta = new Uint8Array(6);
-        const sz = size + 3;
-        meta[0] = 5 /* includeOp.REFERENCE */;
-        meta[1] = sz;
-        meta[2] = sz >>> 8;
-        meta[3] = def.schema.idUint8[0];
-        meta[4] = def.schema.idUint8[1];
-        meta[5] = def.target.propDef.prop;
-        result.push(meta);
+        result.push(referenceQuery(def, size));
     }
     result.push(...include);
     if (edges) {
@@ -249,10 +100,32 @@ export function defToBuffer(db, def) {
         result.push(metaEdgeBuffer, ...edges);
     }
     if (def.type === QueryDefType.Root) {
-        const checksum = new Uint8Array(8);
-        writeUint64(checksum, def.schemaChecksum ?? 0, 0);
-        result.push(checksum);
+        result.push(schemaChecksum(def));
     }
     return result;
 }
+export const queryToBuffer = (query) => {
+    const bufs = defToBuffer(query.db, query.def);
+    // allow both uint8 and def
+    let totalByteLength = bufs.reduce((acc, cur) => acc + cur.buffer.byteLength, 0);
+    const res = new Uint8Array(totalByteLength);
+    let offset = 0;
+    for (let i = 0; i < bufs.length; i++) {
+        const intermediateResult = bufs[i];
+        if (intermediateResult instanceof Uint8Array) {
+            res.set(intermediateResult, offset);
+            offset += intermediateResult.byteLength;
+        }
+        else {
+            if (intermediateResult.needsMetaResolve) {
+                if (intermediateResult.def.filter.hasSubMeta) {
+                    resolveMetaIndexes(intermediateResult.def.filter, offset);
+                }
+            }
+            res.set(intermediateResult.buffer, offset);
+            offset += intermediateResult.buffer.byteLength;
+        }
+    }
+    return res;
+};
 //# sourceMappingURL=toByteCode.js.map

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

@@ -1,6 +1,6 @@
 import { LangCode, LangName } from '@based/schema';
 import { PropDef, PropDefEdge, SchemaTypeDef } from '@based/schema/def';
-import { FilterOpts } from './filter/types.js';
+import { FilterCtx, FilterOpts } from './filter/types.js';
 import { QueryError } from './validation.js';
 import { Interval, aggFnOptions } from './aggregates/types.js';
 import { AggregateType, ReaderSchema } from '@based/protocol/db-read';
@@ -52,7 +52,19 @@ export type Target = {
     };
 };
 export declare const isRefDef: (def: QueryDef) => def is QueryDefRest;
-export type FilterCondition = Uint8Array;
+export type FilterMetaNow = {
+    byteIndex: number;
+    resolvedByteIndex: number;
+    offset: number;
+    ctx: FilterCtx;
+    prop: PropDef | PropDefEdge;
+};
+export type FilterCondition = {
+    buffer: Uint8Array;
+    subscriptionMeta?: {
+        now?: FilterMetaNow[];
+    };
+};
 export type QueryDefFilter = {
     size: number;
     conditions: Map<number, FilterCondition[]>;
@@ -66,6 +78,7 @@ export type QueryDefFilter = {
     edges?: Map<number, FilterCondition[]>;
     or?: QueryDefFilter;
     and?: QueryDefFilter;
+    hasSubMeta: boolean;
 };
 export type QueryDefSearch = {
     size: number;
@@ -95,9 +108,10 @@ export type QueryDefSort = {
 };
 export type Aggregation = {
     type: AggregateType;
-    propDef: PropDef;
+    propDef: PropDef | PropDefEdge;
     resultPos: number;
     accumulatorPos: number;
+    isEdge: boolean;
 };
 export type QueryDefAggregation = {
     size: number;
@@ -115,7 +129,7 @@ export interface aggPropDef extends PropDef {
 }
 export type LangFallback = LangName | false;
 export type QueryDefShared = {
-    queryId?: number;
+    queryType: QueryType;
     schemaChecksum?: number;
     errors: QueryError[];
     lang: {
@@ -167,10 +181,15 @@ export type QueryByAliasObj = {
 export declare const isAlias: (id: Promise<number> | QueryByAliasObj | number | Uint32Array | (QueryByAliasObj | number | Promise<number>)[]) => id is QueryByAliasObj;
 export declare const enum includeOp {
     DEFAULT = 1,
-    REFERENCES_AGGREGATION = 2,
+    REFS_AGGREGATION = 2,
     EDGE = 3,
     REFERENCES = 4,
     REFERENCE = 5,
     META = 6,// this can be a small buffer as well
     PARTIAL = 7
 }
+export type IntermediateByteCode = {
+    buffer: Uint8Array;
+    def: QueryDef;
+    needsMetaResolve?: boolean;
+} | Uint8Array;

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

@@ -2,6 +2,7 @@ import { PropDef, PropDefEdge, SchemaTypeDef } from '@based/schema/def';
 import { DbClient } from '../index.js';
 import { Filter } from './query.js';
 import { QueryByAliasObj, QueryDef } from './types.js';
+import { Validation } from '@based/schema';
 import { StepInput } from './aggregates/types.js';
 export type QueryError = {
     code: number;
@@ -35,6 +36,7 @@ export declare const ERR_AGG_ENOENT = 25;
 export declare const ERR_AGG_TYPE = 26;
 export declare const ERR_AGG_INVALID_STEP_TYPE = 27;
 export declare const ERR_AGG_INVALID_STEP_RANGE = 28;
+export declare const ERR_AGG_NOT_IMPLEMENTED = 29;
 declare const messages: {
     1: (p: any) => string;
     2: (p: any) => string;
@@ -64,13 +66,14 @@ declare const messages: {
     26: (p: any) => string;
     27: (p: any) => string;
     28: (p: any) => string;
+    29: (p: any) => string;
 };
 export type ErrorCode = keyof typeof messages;
 export declare const searchIncorrecQueryValue: (def: QueryDef, payload: any) => void;
 export declare const searchIncorrectType: (def: QueryDef, payload: PropDef | PropDefEdge) => void;
 export declare const searchDoesNotExist: (def: QueryDef, field: string, isVector: boolean) => PropDef;
 export declare const validateRange: (def: QueryDef, offset: number, limit: number) => boolean;
-export declare const validateVal: (def: QueryDef, f: Filter, validate: (v: any, p: PropDef | PropDefEdge) => boolean) => boolean;
+export declare const validateVal: (def: QueryDef, f: Filter, validate: Validation) => boolean;
 export declare const validateFilter: (def: QueryDef, prop: PropDef | PropDefEdge, f: Filter) => boolean;
 export declare const validateType: (db: DbClient, def: QueryDef, type: string) => SchemaTypeDef;
 export declare const filterOperatorDoesNotExist: (def: QueryDef, field: string) => void;
@@ -94,4 +97,5 @@ export declare const EMPTY_SCHEMA_DEF: SchemaTypeDef;
 export declare const aggregationFieldDoesNotExist: (def: QueryDef, field: string) => void;
 export declare const aggregationFieldNotNumber: (def: QueryDef, field: string) => void;
 export declare const validateStepRange: (def: QueryDef, step: StepInput) => void;
+export declare const edgeNotImplemented: (def: QueryDef, field: string) => void;
 export {};

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

@@ -32,6 +32,7 @@ export const ERR_AGG_ENOENT = 25;
 export const ERR_AGG_TYPE = 26;
 export const ERR_AGG_INVALID_STEP_TYPE = 27;
 export const ERR_AGG_INVALID_STEP_RANGE = 28;
+export const ERR_AGG_NOT_IMPLEMENTED = 29;
 const messages = {
     [ERR_TARGET_INVAL_TYPE]: (p) => `Type "${p}" does not exist`,
     [ERR_TARGET_INVAL_ALIAS]: (p) => {
@@ -53,7 +54,7 @@ const messages = {
         return `Filter: Invalid value ${p[0]} ${operatorReverseMap[p[1].operation]} "${safeStringify(p[2])}"`;
     },
     [ERR_SORT_ENOENT]: (p) => `Sort: field does not exist "${p}"`,
-    [ERR_SORT_WRONG_TARGET]: (p) => `Sort: incorrect qeury target "${displayTarget(p)}"`,
+    [ERR_SORT_WRONG_TARGET]: (p) => `Sort: incorrect query target "${displayTarget(p)}"`,
     [ERR_SORT_ORDER]: (p) => `Sort: incorrect order option "${safeStringify(p.order)}" passed to sort "${p.field}"`,
     [ERR_SORT_TYPE]: (p) => `Sort: cannot sort on type "${REVERSE_TYPE_INDEX_MAP[p.typeIndex]}" on field "${p.path.join('.')}"`,
     [ERR_RANGE_INVALID_OFFSET]: (p) => `Range: incorrect start "${safeStringify(p)}"`,
@@ -67,6 +68,7 @@ const messages = {
     [ERR_AGG_TYPE]: (p) => `Aggregate: incorrect type "${p.path.join('.')}"`,
     [ERR_AGG_INVALID_STEP_TYPE]: (p) => `Aggregate: Incorrect step type "${p}"`,
     [ERR_AGG_INVALID_STEP_RANGE]: (p) => `Aggregate: Incorrect step range "${p}". Step ranges are limited to uint32 max value in seconds => group by ~136 years.`,
+    [ERR_AGG_NOT_IMPLEMENTED]: (p) => `Aggregate: Can't aggregate, feature not implemented yet. Prop: "${p}".`,
 };
 export const searchIncorrecQueryValue = (def, payload) => {
     def.errors.push({ code: ERR_SEARCH_INCORRECT_VALUE, payload });
@@ -112,13 +114,13 @@ export const validateVal = (def, f, validate) => {
     const value = f[2];
     if (Array.isArray(value)) {
         for (const v of value) {
-            if (!validate(v, f[2])) {
+            if (validate(v, f[2].schema) !== true) {
                 def.errors.push({ code: ERR_FILTER_INVALID_VAL, payload: f });
                 return true;
             }
         }
     }
-    else if (!validate(value, f[2])) {
+    else if (validate(value, f[2].schema) !== true) {
         def.errors.push({
             code: ERR_FILTER_INVALID_VAL,
             payload: f,
@@ -447,6 +449,7 @@ export const handleErrors = (def) => {
     }
 };
 export const EMPTY_ALIAS_PROP_DEF = {
+    schema: null,
     prop: 1,
     typeIndex: ALIAS,
     __isPropDef: true,
@@ -458,6 +461,7 @@ export const EMPTY_ALIAS_PROP_DEF = {
     path: ['ERROR_ALIAS'],
 };
 export const ERROR_STRING = {
+    schema: null,
     prop: 1,
     typeIndex: STRING,
     __isPropDef: true,
@@ -469,6 +473,7 @@ export const ERROR_STRING = {
     path: ['ERROR_STRING'],
 };
 export const ERROR_VECTOR = {
+    schema: null,
     prop: 1,
     typeIndex: VECTOR,
     __isPropDef: true,
@@ -510,4 +515,11 @@ export const validateStepRange = (def, step) => {
         handleErrors(def);
     }
 };
+export const edgeNotImplemented = (def, field) => {
+    def.errors.push({
+        code: ERR_AGG_NOT_IMPLEMENTED,
+        payload: field,
+    });
+    handleErrors(def);
+};
 //# sourceMappingURL=validation.js.map

package/dist/src/client/string.js

@@ -36,7 +36,7 @@ export const write = (ctx, value, offset, noCompression, lang) => {
     }
     else {
         buf[offset + 1] = NOT_COMPRESSED;
-        writeUint32(buf, crc, offset + l + 2);
+        writeUint32(buf, crc, offset + 2 + l);
         return l + 6;
     }
 };

package/dist/src/hooks.js

@@ -1,35 +1,8 @@
-import picocolors from 'picocolors';
-import { displayTarget } from './client/query/display.js';
+import { registerSubscription } from './server/subscription.js';
 export const getDefaultHooks = (server, subInterval = 200) => {
     return {
         subscribe(q, onData, onError) {
-            let timer;
-            let killed = false;
-            const poll = async () => {
-                const res = await server.getQueryBuf(q.buffer);
-                if (killed) {
-                    return;
-                }
-                if (res.byteLength >= 4) {
-                    onData(res);
-                }
-                else if (res.byteLength === 1 && res[0] === 0) {
-                    server.emit('info', `[${displayTarget(q.def)}] Subscribe schema mismatch - should resolve after update`);
-                    return;
-                }
-                else {
-                    const def = q.def;
-                    let name = picocolors.red(`QueryError[${displayTarget(def)}]\n`);
-                    name += `  Incorrect buffer received in subscription (maybe server not started ${res.byteLength}) bytes\n`;
-                    onError(new Error(name));
-                }
-                timer = setTimeout(poll, subInterval);
-            };
-            void poll();
-            return () => {
-                clearTimeout(timer);
-                killed = true;
-            };
+            return registerSubscription(server, q.buffer, q.subscriptionBuffer, onData, onError, subInterval);
         },
         setSchema(schema, transformFns) {
             return server.setSchema(schema, transformFns);

package/dist/src/index.d.ts

@@ -15,6 +15,7 @@ export * from './client/query/BasedDbQuery.js';
 export * from './client/query/BasedQueryResponse.js';
 export * from './server/save.js';
 export * from './hooks.js';
+export * from './server/subscription.js';
 export { getDefaultHooks, BasedDbOpts };
 export declare class BasedDb extends Emitter {
     client: DbClient;

package/dist/src/index.js

@@ -16,6 +16,7 @@ export * from './client/query/BasedDbQuery.js';
 export * from './client/query/BasedQueryResponse.js';
 export * from './server/save.js';
 export * from './hooks.js';
+export * from './server/subscription.js';
 export { getDefaultHooks };
 export class BasedDb extends Emitter {
     client;

package/dist/src/native.d.ts

@@ -1,4 +1,10 @@
 declare const native: {
+    addMultiSubscription: (dbCtx: any, typeId: number) => void;
+    removeMultiSubscription: (dbCtx: any, typeId: number) => void;
+    removeIdSubscription: (dbCtx: any, value: Uint8Array) => void;
+    addIdSubscription: (dbCtx: any, value: Uint8Array) => void;
+    getMarkedIdSubscriptions: (dbCtx: any) => ArrayBuffer | null;
+    getMarkedMultiSubscriptions: (dbCtx: any) => ArrayBuffer | null;
     getThreadId: () => BigInt;
     createThreadCtx: (dbCtx: any, threadId: BigInt) => void;
     destroyThreadCtx: (dbCtx: any, threadId: BigInt) => void;
@@ -13,7 +19,7 @@ declare const native: {
     loadCommon: (path: string, dbCtx: any) => void;
     loadBlock: (path: string, dbCtx: any) => void;
     delBlock: (dbCtx: any, typeId: number, block: number) => void;
-    setSchemaType: (prefix: number, buf: Uint8Array, dbCtx: any) => any;
+    setSchemaType: (dbCtx: any, prefix: number, buf: Uint8Array) => any;
     setSchemaIds: (ids: Uint32Array, dbCtx: any) => any;
     getSchemaIds: (dbCtx: any) => Uint32Array;
     getNodeRangeHash: (typeId: number, start: number, end: number, bufOut: Uint8Array, dbCtx: any) => any;
@@ -29,6 +35,7 @@ declare const native: {
     membarSyncRead: () => void;
     membarSyncWrite: () => void;
     selvaStrerror: (err: number) => any;
+    selvaLangAll: () => string;
     colvecTest: (dbCtx: any, typeId: number, field: number, nodeId: number, len: number) => any;
 };
 export default native;

package/dist/src/native.js

@@ -10,6 +10,24 @@ function SelvaIoErrlogToString(buf) {
     return DECODER.decode(selvaIoErrlog.slice(0, len));
 }
 const native = {
+    addMultiSubscription: (dbCtx, typeId) => {
+        return db.addMultiSubscription(dbCtx, typeId);
+    },
+    removeMultiSubscription: (dbCtx, typeId) => {
+        return db.removeMultiSubscription(dbCtx, typeId);
+    },
+    removeIdSubscription: (dbCtx, value) => {
+        return db.removeIdSubscription(dbCtx, value);
+    },
+    addIdSubscription: (dbCtx, value) => {
+        return db.addIdSubscription(dbCtx, value);
+    },
+    getMarkedIdSubscriptions: (dbCtx) => {
+        return db.getMarkedIdSubscriptions(dbCtx);
+    },
+    getMarkedMultiSubscriptions: (dbCtx) => {
+        return db.getMarkedMultiSubscriptions(dbCtx);
+    },
     getThreadId: () => {
         return db.getThreadId();
     },
@@ -63,8 +81,8 @@ const native = {
     delBlock: (dbCtx, typeId, block) => {
         db.delBlock(dbCtx, typeId, block);
     },
-    setSchemaType: (prefix, buf, dbCtx) => {
-        return db.setSchemaType(prefix, buf, dbCtx);
+    setSchemaType: (dbCtx, prefix, buf) => {
+        return db.setSchemaType(dbCtx, prefix, buf);
     },
     setSchemaIds: (ids, dbCtx) => {
         return db.setSchemaIds(ids, dbCtx);
@@ -111,6 +129,9 @@ const native = {
     selvaStrerror: (err) => {
         return db.selvaStrerror(err);
     },
+    selvaLangAll: () => {
+        return db.selvaLangAll();
+    },
     colvecTest: (dbCtx, typeId, field, nodeId, len) => {
         return db.colvecTest(dbCtx, typeId, field, nodeId, len);
     },

package/dist/src/server/index.d.ts

@@ -5,6 +5,7 @@ import exitHook from 'exit-hook';
 import { IoWorker } from './IoWorker.js';
 import { QueryWorker } from './QueryWorker.js';
 import { DbShared } from '../shared/DbBase.js';
+import { Subscriptions } from './subscription.js';
 declare class SortIndex {
     constructor(buf: Uint8Array, dbCtxExternal: any);
     buf: Uint8Array;
@@ -15,6 +16,7 @@ export declare class DbServer extends DbShared {
     #private;
     modifyDirtyRanges: Float64Array;
     dbCtxExternal: any;
+    subscriptions: Subscriptions;
     migrating: number;
     saveInProgress: boolean;
     fileSystemPath: string;