@based/db 0.0.42 → 0.0.44

package/dist/lib/darwin_aarch64/include/selva/fields.h

@@ -377,8 +377,6 @@ void selva_fields_init(const struct SelvaFieldsSchema *schema, struct SelvaField
 
 /**
  * Destroy all fields of a node.
- * This will set nr_fields = 0, making setting new field values impossible
- * regardless wether the schema defines fields for this node.
  */
 SELVA_EXPORT
 void selva_fields_destroy(struct SelvaDb *db, struct SelvaNode *node, selva_dirty_node_cb_t dirty_cb, void *dirty_ctx)

package/dist/lib/linux_aarch64/include/selva/fields.h

@@ -377,8 +377,6 @@ void selva_fields_init(const struct SelvaFieldsSchema *schema, struct SelvaField
 
 /**
  * Destroy all fields of a node.
- * This will set nr_fields = 0, making setting new field values impossible
- * regardless wether the schema defines fields for this node.
  */
 SELVA_EXPORT
 void selva_fields_destroy(struct SelvaDb *db, struct SelvaNode *node, selva_dirty_node_cb_t dirty_cb, void *dirty_ctx)

package/dist/lib/linux_x86_64/include/selva/fields.h

@@ -377,8 +377,6 @@ void selva_fields_init(const struct SelvaFieldsSchema *schema, struct SelvaField
 
 /**
  * Destroy all fields of a node.
- * This will set nr_fields = 0, making setting new field values impossible
- * regardless wether the schema defines fields for this node.
  */
 SELVA_EXPORT
 void selva_fields_destroy(struct SelvaDb *db, struct SelvaNode *node, selva_dirty_node_cb_t dirty_cb, void *dirty_ctx)

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

@@ -27,6 +27,8 @@ export declare class ModifyCtx {
     markTypeDirty(schema: SchemaTypeDef): void;
     updateMax(): void;
     getData(lastIds: Record<number, number>): Uint8Array;
+    reset(): void;
 }
+export declare const execCtxQueue: (resCtx: ModifyCtx["ctx"], error?: boolean) => void;
 export declare const flushBuffer: (db: DbClient) => Promise<void>;
 export declare const startDrain: (db: DbClient) => void;

package/dist/src/client/flushModify.js

@@ -1,3 +1,4 @@
+import { writeUint64 } from '@saulx/utils';
 // TODO This definitely shouldn't be copy-pasted here from server/tree.ts
 const makeCsmtKeyFromNodeId = (typeId, blockCapacity, nodeId) => {
     const tmp = nodeId - +!(nodeId % blockCapacity);
@@ -8,9 +9,10 @@ export class ModifyCtx {
         this.max = db.maxModifySize;
         this.db = db;
         this.buf = new Uint8Array(db.maxModifySize);
+        this.reset();
     }
     // default values
-    len = 0;
+    len = 8;
     id = -1;
     hasSortField = -1;
     hasSortText = -1;
@@ -79,17 +81,50 @@ export class ModifyCtx {
             view.setFloat64(i, key, true);
             i += 8;
         }
-        data[i++] = this.len;
-        data[i++] = this.len >>> 8;
-        data[i++] = this.len >>> 16;
-        data[i++] = this.len >>> 24;
+        const lenMinusSchemaHash = this.len - 8;
+        data[i++] = lenMinusSchemaHash;
+        data[i++] = lenMinusSchemaHash >>> 8;
+        data[i++] = lenMinusSchemaHash >>> 16;
+        data[i++] = lenMinusSchemaHash >>> 24;
         return data;
     }
+    reset() {
+        this.dirtyTypes.clear();
+        this.dirtyRanges.clear();
+        writeUint64(this.buf, this.db.schema?.hash || 0, 0);
+        this.len = 8;
+        this.prefix0 = -1;
+        this.prefix1 = -1;
+        this.lastMain = -1;
+        // should these also be reset in setcursor?
+        this.hasSortText = -1;
+        this.hasSortField = -1;
+        this.max = this.db.maxModifySize;
+        this.ctx = {};
+    }
 }
+export const execCtxQueue = (resCtx, error) => {
+    if (resCtx.queue?.size) {
+        const queue = resCtx.queue;
+        resCtx.queue = null;
+        if (error) {
+            for (const [resolve] of queue) {
+                // should we throw?
+                resolve(null);
+            }
+        }
+        else {
+            for (const [resolve, res] of queue) {
+                resolve(res.getId());
+            }
+        }
+    }
+};
 export const flushBuffer = (db) => {
     const ctx = db.modifyCtx;
     let flushPromise;
-    if (ctx.len) {
+    if (ctx.len > 8) {
+        // always has schema hash
         const lastIds = {};
         const data = ctx.getData(lastIds);
         const resCtx = ctx.ctx;
@@ -98,37 +133,31 @@ export const flushBuffer = (db) => {
             .flushModify(data)
             .then(({ offsets, dbWriteTime }) => {
             db.writeTime += dbWriteTime ?? 0;
-            resCtx.offsets = offsets;
-            for (const typeId in lastIds) {
-                if (typeId in offsets) {
-                    const lastId = lastIds[typeId] + offsets[typeId];
-                    const def = db.schemaTypesParsedById[typeId];
-                    const delta = lastId - def.lastId;
-                    if (delta > 0) {
-                        def.lastId += delta;
-                        def.total += delta;
+            if (offsets) {
+                resCtx.offsets = offsets;
+                for (const typeId in lastIds) {
+                    if (typeId in offsets) {
+                        const lastId = lastIds[typeId] + offsets[typeId];
+                        const def = db.schemaTypesParsedById[typeId];
+                        const delta = lastId - def.lastId;
+                        if (delta > 0) {
+                            def.lastId += delta;
+                            def.total += delta;
+                        }
+                    }
+                    else {
+                        console.error('Panic: No offset returned in flushModify');
                     }
                 }
-                else {
-                    console.error('Panic: No offset returned in flushModify');
-                }
+                execCtxQueue(resCtx);
             }
-            if (resCtx.queue?.size) {
-                const queue = resCtx.queue;
-                resCtx.queue = null;
-                for (const [resolve, res] of queue) {
-                    resolve(res.getId());
-                }
+            else {
+                console.info('Modify cancelled - schema mismatch');
+                execCtxQueue(resCtx, true);
             }
             db.flushReady();
         });
-        ctx.dirtyTypes.clear();
-        ctx.dirtyRanges.clear();
-        ctx.len = 0;
-        ctx.prefix0 = -1;
-        ctx.prefix1 = -1;
-        ctx.max = db.maxModifySize;
-        ctx.ctx = {};
+        ctx.reset();
     }
     else {
         db.flushReady();

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

@@ -23,9 +23,7 @@ type DbClientOpts = {
     flushTime?: number;
     debug?: boolean;
 };
-type DbClientSchema = StrictSchema & {
-    lastId: number;
-};
+type DbClientSchema = DbServer['schema'];
 export declare class DbClient {
     constructor({ hooks, maxModifySize, flushTime, debug, }: DbClientOpts);
     flushTime: number;
@@ -43,11 +41,13 @@ export declare class DbClient {
         o: Record<string, any>;
         p: Promise<number | ModifyRes>;
     }>;
-    schemaChecksum: number;
     schemaProcessing: number;
     schemaPromise: Promise<DbServer['schema']>;
     setSchema(schema: Schema, fromStart?: boolean, transformFns?: TransformFns): Promise<StrictSchema>;
-    putLocalSchema(schema: any): DbClientSchema;
+    putLocalSchema(schema: DbServer['schema']): StrictSchema & {
+        lastId: number;
+        hash?: number;
+    };
     create(type: string, obj?: CreateObj, opts?: ModifyOpts): ModifyRes;
     copy(type: string, target: number | ModifyRes, objOrTransformFn?: Record<string, any> | ((item: Record<string, any>) => Promise<any>)): Promise<ModifyRes>;
     query(type: string, id?: number | ModifyRes | (number | ModifyRes)[] | QueryByAliasObj | QueryByAliasObj[] | Uint32Array): BasedDbQuery;

package/dist/src/client/index.js

@@ -1,7 +1,7 @@
 import { parse } from '@based/schema';
 import { create } from './modify/create.js';
 import { updateTypeDefs, schemaToSelvaBuffer, } from '@based/schema/def';
-import { flushBuffer, ModifyCtx, startDrain } from './flushModify.js';
+import { execCtxQueue, flushBuffer, ModifyCtx, startDrain, } from './flushModify.js';
 import { BasedDbQuery } from './query/BasedDbQuery.js';
 import { ModifyState } from './modify/ModifyRes.js';
 import { upsert } from './modify/upsert.js';
@@ -43,7 +43,6 @@ export class DbClient {
     modifyCtx;
     maxModifySize;
     upserting = new Map();
-    schemaChecksum;
     schemaProcessing;
     schemaPromise;
     async setSchema(schema, fromStart, transformFns) {
@@ -52,6 +51,8 @@ export class DbClient {
         if (schemaLooseEqual(strictSchema, this.schema)) {
             return this.schema;
         }
+        // drain current things
+        await this.drain();
         const checksum = hash(strictSchema);
         if (checksum !== this.schemaProcessing) {
             this.schemaProcessing = checksum;
@@ -63,15 +64,20 @@ export class DbClient {
         return this.putLocalSchema(remoteSchema);
     }
     putLocalSchema(schema) {
-        const checksum = hash(schema);
-        if (this.schemaChecksum === checksum) {
+        if (this.schema && this.schema.hash === schema.hash) {
             return this.schema;
         }
-        this.schemaChecksum = checksum;
         this.schema = schema;
         updateTypeDefs(this.schema, this.schemaTypesParsed, this.schemaTypesParsedById);
         // Adds bidrectional refs on defs
         schemaToSelvaBuffer(this.schemaTypesParsed);
+        // this has to happen before the listeners
+        if (this.modifyCtx.len > 8) {
+            console.info('Modify cancelled - schema updated');
+        }
+        const resCtx = this.modifyCtx.ctx;
+        this.modifyCtx.reset();
+        execCtxQueue(resCtx, true);
         if (this.listeners?.schema) {
             for (const cb of this.listeners.schema) {
                 cb(this.schema);
@@ -88,11 +94,11 @@ export class DbClient {
             .get()
             .toObject();
         if (typeof objOrTransformFn === 'function') {
-            const { id, ...props } = await objOrTransformFn(item);
+            const { id: _, ...props } = await objOrTransformFn(item);
             return this.create(type, props);
         }
         if (typeof objOrTransformFn === 'object' && objOrTransformFn !== null) {
-            const { id, ...props } = item;
+            const { id: _, ...props } = item;
             await Promise.all(Object.keys(objOrTransformFn).map(async (key) => {
                 const val = objOrTransformFn[key];
                 if (val === null) {
@@ -113,7 +119,7 @@ export class DbClient {
             }));
             return this.create(type, props);
         }
-        const { id, ...props } = item;
+        const { id: _, ...props } = item;
         return this.create(type, props);
     }
     query(type, id) {

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

@@ -1,4 +1,4 @@
-import { QueryDef, Operator, QueryByAliasObj } from './query.js';
+import { QueryDef, QueryTarget, Operator, QueryByAliasObj } from './query.js';
 import { BasedQueryResponse } from './BasedIterable.js';
 import { Search } from './search/index.js';
 import { OnData, OnError } from './subscription/index.js';
@@ -8,9 +8,14 @@ import { FilterAst, FilterBranchFn, FilterOpts } from './filter/types.js';
 export { QueryByAliasObj };
 export type SelectFn = (field: string) => BasedDbReferenceQuery;
 export type BranchInclude = (select: SelectFn) => any;
+export type QueryCommand = {
+    method: string;
+    args: any[];
+};
 export declare class QueryBranch<T> {
     db: DbClient;
     def: QueryDef;
+    queryCommands: QueryCommand[];
     constructor(db: DbClient, def: QueryDef);
     sort(field: string, order?: 'asc' | 'desc'): T;
     filter<O extends Operator>(field: string, operator?: O | boolean, value?: any, opts?: FilterOpts<O>): T;
@@ -35,7 +40,9 @@ declare class GetPromise extends Promise<BasedQueryResponse> {
 export declare class BasedDbQuery extends QueryBranch<BasedDbQuery> {
     #private;
     skipValidation: boolean;
-    constructor(db: DbClient, type: string, id?: QueryByAliasObj | number | Uint32Array | (QueryByAliasObj | number)[], skipValidation?: boolean);
+    target: QueryTarget;
+    constructor(db: DbClient, type: string, rawTarget?: QueryByAliasObj | number | Uint32Array | (QueryByAliasObj | number)[], skipValidation?: boolean);
+    reBuildQuery(): void;
     id: number;
     get(): GetPromise;
     buffer: Uint8Array;

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

@@ -15,16 +15,29 @@ import { concatUint8Arr } from '@saulx/utils';
 export class QueryBranch {
     db;
     def;
+    queryCommands;
     constructor(db, def) {
         this.db = db;
         this.def = def;
     }
     sort(field, order = 'asc') {
+        if (this.queryCommands) {
+            this.queryCommands.push({
+                method: 'filter',
+                args: [field, order],
+            });
+        }
         sort(this.def, field, order);
         // @ts-ignore
         return this;
     }
     filter(field, operator, value, opts) {
+        if (this.queryCommands) {
+            this.queryCommands.push({
+                method: 'filter',
+                args: [field, operator, value, opts],
+            });
+        }
         const f = convertFilter(this.def, field, operator, value, opts);
         if (!f) {
             // @ts-ignore
@@ -35,11 +48,23 @@ export class QueryBranch {
         return this;
     }
     filterBatch(f) {
+        if (this.queryCommands) {
+            this.queryCommands.push({
+                method: 'filterBatch',
+                args: [f],
+            });
+        }
         filter(this.db, this.def, f, this.def.filter);
         // @ts-ignore
         return this;
     }
     search(query, field, opts, ...fields) {
+        if (this.queryCommands) {
+            this.queryCommands.push({
+                method: 'search',
+                args: [query, field, opts, ...fields],
+            });
+        }
         if (ArrayBuffer.isView(query)) {
             // @ts-ignore
             vectorSearch(this.def, query, field, opts ?? {});
@@ -95,23 +120,47 @@ export class QueryBranch {
         return this;
     }
     groupBy(field) {
+        if (this.queryCommands) {
+            this.queryCommands.push({
+                method: 'groupBy',
+                args: [field],
+            });
+        }
         groupBy(this.def, field);
         // only works with aggregates for now
         // @ts-ignore
         return this;
     }
     count(field = '$count') {
+        if (this.queryCommands) {
+            this.queryCommands.push({
+                method: 'count',
+                args: [field],
+            });
+        }
         const p = field.split('.');
         addAggregate(2 /* AggregateType.COUNT */, this.def, p);
         // @ts-ignore
         return this;
     }
     sum(...fields) {
+        if (this.queryCommands) {
+            this.queryCommands.push({
+                method: 'sum',
+                args: fields,
+            });
+        }
         addAggregate(1 /* AggregateType.SUM */, this.def, fields);
         // @ts-ignore
         return this;
     }
     or(field, operator, value, opts) {
+        if (this.queryCommands) {
+            this.queryCommands.push({
+                method: 'or',
+                args: [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);
@@ -127,6 +176,9 @@ export class QueryBranch {
         return this;
     }
     range(start, end = DEF_RANGE_PROP_LIMIT) {
+        if (this.queryCommands) {
+            this.queryCommands.push({ method: 'range', args: [start, end] });
+        }
         const offset = start;
         const limit = end - start;
         if (validateRange(this.def, offset, limit)) {
@@ -141,6 +193,9 @@ export class QueryBranch {
         return this;
     }
     include(...fields) {
+        if (this.queryCommands) {
+            this.queryCommands.push({ method: 'include', args: fields });
+        }
         for (const f of fields) {
             if (typeof f === 'string') {
                 includeField(this.def, f);
@@ -206,22 +261,23 @@ class GetPromise extends Promise {
 }
 export class BasedDbQuery extends QueryBranch {
     skipValidation = false;
-    constructor(db, type, id, skipValidation) {
+    target;
+    constructor(db, type, rawTarget, skipValidation) {
         const target = {
             type,
         };
-        if (id) {
-            if (isAlias(id)) {
-                target.alias = id;
+        if (rawTarget) {
+            if (isAlias(rawTarget)) {
+                target.alias = rawTarget;
             }
             else {
-                if (Array.isArray(id) || id instanceof Uint32Array) {
+                if (Array.isArray(rawTarget) || rawTarget instanceof Uint32Array) {
                     // TODO ADD MULTI ALIAS
                     // @ts-ignore
-                    target.ids = id;
+                    target.ids = rawTarget;
                 }
                 else {
-                    target.id = id;
+                    target.id = rawTarget;
                 }
             }
         }
@@ -230,6 +286,21 @@ export class BasedDbQuery extends QueryBranch {
         }
         const def = createQueryDef(db, QueryDefType.Root, target, skipValidation);
         super(db, def);
+        this.db = db;
+        this.skipValidation = skipValidation;
+        this.queryCommands = [];
+        this.target = target;
+    }
+    reBuildQuery() {
+        this.id = undefined;
+        this.buffer = undefined;
+        const def = createQueryDef(this.db, QueryDefType.Root, this.target, this.skipValidation);
+        this.def = def;
+        const q = this.queryCommands;
+        this.queryCommands = [];
+        for (const command of q) {
+            this[command.method](...command.args);
+        }
     }
     #getInternal = async (resolve, reject) => {
         if (!this.def.include.stringFields.size && !this.def.references.size) {

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

@@ -3,3 +3,4 @@ import { AggregateType } from './types.js';
 export declare const aggregateToBuffer: (aggregates: QueryDefAggregation) => Uint8Array;
 export declare const groupBy: (def: QueryDef, field: string) => void;
 export declare const addAggregate: (type: AggregateType, def: QueryDef, fields: (string | string[])[]) => void;
+export declare const isRootCountOnly: (def: QueryDef, filterSize: number) => boolean;

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

@@ -1,4 +1,5 @@
 import { writeUint16 } from '@saulx/utils';
+import { QueryDefType } from '../types.js';
 import { UINT32 } from '@based/schema/def';
 import { aggregationFieldDoesNotExist } from '../validation.js';
 export const aggregateToBuffer = (aggregates) => {
@@ -107,4 +108,29 @@ export const addAggregate = (type, def, fields) => {
         }
     }
 };
+export const isRootCountOnly = (def, filterSize) => {
+    if (filterSize != 0) {
+        return false;
+    }
+    if (def.type !== QueryDefType.Root) {
+        return false;
+    }
+    if (def.aggregate.groupBy) {
+        return false;
+    }
+    if (def.aggregate.aggregates.size !== 1) {
+        return false;
+    }
+    if (!def.aggregate.aggregates.has(255)) {
+        return false;
+    }
+    const aggs = def.aggregate.aggregates.get(255);
+    if (aggs.length !== 1) {
+        return false;
+    }
+    if (aggs[0].type !== 2 /* AggregateType.COUNT */) {
+        return false;
+    }
+    return true;
+};
 //# sourceMappingURL=aggregation.js.map

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

@@ -215,8 +215,9 @@ const inspectObject = (object, q, path, level, isLast, isFirst, isObject, depth)
                         str += picocolors.blue(v);
                         str += picocolors.italic(picocolors.dim(` ${key.indexOf('count') >= 0 ? ' count' : ' sum'}`));
                     }
-                    // str += ',\n'
-                    // str += picocolors.blue(v)
+                    else {
+                        str += picocolors.blue(v);
+                    }
                 }
                 else if (typeof v === 'object' && v) {
                     inspectObject(v, q, key, level + 2, false, false, true, depth) + '';

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

@@ -4,6 +4,7 @@ import { defToBuffer } from './toBuffer.js';
 import { handleErrors } from './validation.js';
 export const registerQuery = (q) => {
     if (!q.id) {
+        q.def.schemaChecksum = q.db.schema.hash;
         const b = defToBuffer(q.db, q.def);
         const buf = concatUint8Arr(b);
         let id = native.crc32(buf);

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

@@ -3,8 +3,8 @@ import { QueryDefType, QueryType } from './types.js';
 import { includeToBuffer } from './include/toBuffer.js';
 import { filterToBuffer } from './query.js';
 import { searchToBuffer } from './search/index.js';
-import { ENCODER } from '@saulx/utils';
-import { aggregateToBuffer } from './aggregates/aggregation.js';
+import { ENCODER, writeUint64 } from '@saulx/utils';
+import { aggregateToBuffer, isRootCountOnly } from './aggregates/aggregation.js';
 const byteSize = (arr) => {
     return arr.reduce((a, b) => {
         return a + b.byteLength;
@@ -33,9 +33,6 @@ export function defToBuffer(db, def) {
         edgesSize = byteSize(edges);
     }
     const size = (edges ? edgesSize + 3 : 0) + byteSize(include);
-    // ---------------------------------------
-    // move down and will handle size after store the size Var
-    // only for references | edges
     if (def.aggregate) {
         const aggregateSize = def.aggregate.size || 0;
         if (aggregateSize === 0) {
@@ -43,7 +40,9 @@ export function defToBuffer(db, def) {
         }
         const filterSize = def.filter.size || 0;
         const buf = new Uint8Array(16 + filterSize + aggregateSize);
-        buf[0] = QueryType.aggregates;
+        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;
@@ -66,8 +65,11 @@ export function defToBuffer(db, def) {
         result.push(buf);
         // ignore this for now...
         // result.push(...include)
-        // console.log('toBuffer > result: ', result)
-        // later this has to be a branch
+        if (def.type === QueryDefType.Root) {
+            const checksum = new Uint8Array(8);
+            writeUint64(checksum, def.schemaChecksum ?? 0, 0);
+            result.push(checksum);
+        }
         return result;
     }
     if (def.type === QueryDefType.Root) {
@@ -249,6 +251,11 @@ export function defToBuffer(db, def) {
         metaEdgeBuffer[2] = edgesSize >>> 8;
         result.push(metaEdgeBuffer, ...edges);
     }
+    if (def.type === QueryDefType.Root) {
+        const checksum = new Uint8Array(8);
+        writeUint64(checksum, def.schemaChecksum ?? 0, 0);
+        result.push(checksum);
+    }
     return result;
 }
 //# sourceMappingURL=toBuffer.js.map

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

@@ -12,7 +12,8 @@ export declare enum QueryType {
     ids = 1,
     default = 2,
     alias = 3,
-    aggregates = 4
+    aggregates = 4,
+    aggregatesCountType = 5
 }
 declare enum QueryDefType {
     Edge = 1,
@@ -85,6 +86,7 @@ export type QueryDefAggregation = {
     totalResultsPos: number;
 };
 export type QueryDefShared = {
+    schemaChecksum?: number;
     errors: QueryError[];
     lang: LangCode;
     filter: QueryDefFilter;

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

@@ -5,6 +5,7 @@ export var QueryType;
     QueryType[QueryType["default"] = 2] = "default";
     QueryType[QueryType["alias"] = 3] = "alias";
     QueryType[QueryType["aggregates"] = 4] = "aggregates";
+    QueryType[QueryType["aggregatesCountType"] = 5] = "aggregatesCountType";
 })(QueryType || (QueryType = {}));
 var QueryDefType;
 (function (QueryDefType) {

package/dist/src/index.js

@@ -5,6 +5,7 @@ import { DbClient } from './client/index.js';
 import { wait } from '@saulx/utils';
 import { debugMode, debugServer } from './utils.js';
 import { BasedQueryResponse } from './client/query/BasedIterable.js';
+import { registerQuery } from './client/query/registerQuery.js';
 export * from './client/modify/modify.js';
 export { compress, decompress };
 export { ModifyCtx }; // TODO move this somewhere
@@ -57,6 +58,12 @@ export class BasedDb {
                     let lastLen = 0;
                     let response;
                     const get = async () => {
+                        const schemaVersion = q.def.schemaChecksum;
+                        if (schemaVersion && schemaVersion !== server.schema.hash) {
+                            q.reBuildQuery();
+                            registerQuery(q);
+                            response = undefined;
+                        }
                         const res = await server.getQueryBuf(q.buffer);
                         if (!response) {
                             response = new BasedQueryResponse(q.id, q.def, res, 0);
@@ -71,7 +78,7 @@ export class BasedDb {
                             lastLen = res.byteLength;
                             prevChecksum = checksum;
                         }
-                        setTimeout(get, 200);
+                        timer = setTimeout(get, 200);
                     };
                     get();
                     return () => {

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

@@ -23,7 +23,7 @@ export declare class DbWorker {
     updateCtx(address: BigInt): Promise<void>;
     getQueryBuf(buf: Uint8Array): Promise<Uint8Array>;
 }
-type OnSchemaChange = (schema: StrictSchema) => void;
+type OnSchemaChange = (schema: DbServer['schema']) => void;
 export declare class DbServer {
     #private;
     modifyDirtyRanges: Float64Array;
@@ -99,7 +99,7 @@ export declare class DbServer {
         lastId: number;
         hash?: number;
     }>;
-    modify(buf: Uint8Array): Record<number, number>;
+    modify(buf: Uint8Array): Record<number, number> | null;
     addToQueryQueue(resolve: any, buf: any): void;
     getQueryBuf(buf: Uint8Array, fromQueue?: boolean): Promise<Uint8Array>;
     onQueryEnd(): void;

package/dist/src/server/index.js

@@ -12,6 +12,7 @@ import { fileURLToPath } from 'node:url';
 import { setTimeout } from 'node:timers/promises';
 import { migrate } from './migrate/index.js';
 import { debugServer, schemaLooseEqual } from '../utils.js';
+import { readUint16, readUint32, readUint64, writeUint64 } from '@saulx/utils';
 import { hash } from '@saulx/hash';
 export const SCHEMA_FILE = 'schema.json';
 export const WRITELOG_FILE = 'writelog.json';
@@ -28,12 +29,6 @@ class SortIndex {
     idx;
     cnt = 0;
 }
-function readUint16LE(buf, off) {
-    return buf[off] | (buf[off + 1] << 8);
-}
-function readUint32LE(buf, off) {
-    return (buf[off] | (buf[off + 1] << 8) | (buf[off + 2] << 16) | (buf[off + 3] << 24));
-}
 export class DbWorker {
     constructor(address, db) {
         const { port1, port2 } = new MessageChannel();
@@ -362,14 +357,16 @@ export class DbServer {
                 // TODO fix this add it in schema at least
                 const data = [2, 1, 0, 0, 0, 1, 9, 1, 0, 0, 0, 7, 1, 0, 1];
                 const blockKey = makeCsmtKey(1, 1);
-                const buf = new Uint8Array(data.length + 2 + 8 + 4);
+                const buf = new Uint8Array(8 + data.length + 2 + 8 + 4);
                 const view = new DataView(buf.buffer, 0, buf.byteLength);
+                // set schema hash
+                writeUint64(buf, this.schema.hash, 0);
                 // add content
-                buf.set(data);
+                buf.set(data, 8);
                 // add typesLen
-                view.setFloat64(data.length, 0, true);
+                view.setFloat64(8 + data.length, 0, true);
                 // add dirty key
-                view.setFloat64(data.length + 2, blockKey, true);
+                view.setFloat64(8 + data.length + 2, blockKey, true);
                 // add dataLen
                 view.setUint32(buf.length - 4, data.length, true);
                 this.modify(buf);
@@ -380,14 +377,19 @@ export class DbServer {
         return this.schema;
     }
     modify(buf) {
+        const schemaHash = readUint64(buf, 0);
+        if (schemaHash !== this.schema.hash) {
+            return null;
+        }
+        buf = buf.subarray(8);
         const offsets = {};
-        const dataLen = readUint32LE(buf, buf.length - 4);
-        let typesSize = readUint16LE(buf, dataLen);
+        const dataLen = readUint32(buf, buf.length - 4);
+        let typesSize = readUint16(buf, dataLen);
         let i = dataLen + 2;
         while (typesSize--) {
-            const typeId = readUint16LE(buf, i);
+            const typeId = readUint16(buf, i);
             i += 2;
-            const startId = readUint32LE(buf, i);
+            const startId = readUint32(buf, i);
             const def = this.schemaTypesParsedById[typeId];
             let offset = def.lastId - startId;
             if (offset < 0) {
@@ -397,7 +399,7 @@ export class DbServer {
             buf[i++] = offset >>> 8;
             buf[i++] = offset >>> 16;
             buf[i++] = offset >>> 24;
-            const lastId = readUint32LE(buf, i);
+            const lastId = readUint32(buf, i);
             i += 4;
             def.lastId = lastId + offset;
             offsets[typeId] = offset;
@@ -416,14 +418,14 @@ export class DbServer {
             return;
         }
         const end = buf.length - 4;
-        const dataLen = readUint32LE(buf, end);
-        let typesSize = readUint16LE(buf, dataLen);
+        const dataLen = readUint32(buf, end);
+        let typesSize = readUint16(buf, dataLen);
         const typesLen = typesSize * 10;
         const types = buf.subarray(dataLen + 2, dataLen + typesLen + 2);
         const data = buf.subarray(0, dataLen);
         let i = dataLen + 2;
         while (typesSize--) {
-            const typeId = readUint16LE(buf, i);
+            const typeId = readUint16(buf, i);
             const def = this.schemaTypesParsedById[typeId];
             const key = makeCsmtKeyFromNodeId(def.id, def.blockCapacity, def.lastId);
             this.dirtyRanges.add(key);
@@ -475,13 +477,13 @@ export class DbServer {
         else {
             const queryType = buf[0];
             if (queryType == 2) {
-                const s = 13 + readUint16LE(buf, 11);
-                const sortLen = readUint16LE(buf, s);
+                const s = 13 + readUint16(buf, 11);
+                const sortLen = readUint16(buf, s);
                 if (sortLen) {
-                    const typeId = readUint16LE(buf, 1);
+                    const typeId = readUint16(buf, 1);
                     const sort = buf.slice(s + 2, s + 2 + sortLen);
                     const field = sort[1];
-                    const start = readUint16LE(sort, 3);
+                    const start = readUint16(sort, 3);
                     let sortIndex = this.getSortIndex(typeId, field, start, 0);
                     if (!sortIndex) {
                         if (this.processingQueries) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@based/db",
-  "version": "0.0.42",
+  "version": "0.0.44",
   "license": "MIT",
   "type": "module",
   "main": "./dist/src/index.js",
@@ -38,9 +38,9 @@
     "basedDbNative.cjs"
   ],
   "dependencies": {
-    "@based/schema": "5.0.0-alpha.15",
+    "@based/schema": "5.0.0-alpha.16",
     "@saulx/hash": "^3.0.0",
-    "@saulx/utils": "^6.6.0",
+    "@saulx/utils": "^6.7.0",
     "exit-hook": "^4.0.0",
     "picocolors": "^1.1.0",
     "@based/crc32c": "^1.0.0"