@based/db 0.0.30 → 0.0.32

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

@@ -31,7 +31,7 @@ export const ERR_SORT_LANG = 24;
 const messages = {
     [ERR_TARGET_INVAL_TYPE]: (p) => `Type "${p}" does not exist`,
     [ERR_TARGET_INVAL_ALIAS]: (p) => {
-        return `Invalid alias prodived to query\n  ${picocolors.italic(safeStringify(p, 100))}`;
+        return `Invalid alias provided to query\n  ${picocolors.italic(safeStringify(p, 100))}`;
     },
     [ERR_TARGET_EXCEED_MAX_IDS]: (p) => `Exceeds max ids ${~~(p.length / 1e3)}k (max ${MAX_IDS_PER_QUERY / 1e3}k)`,
     [ERR_TARGET_INVAL_IDS]: (p) => `Ids should be of type array or Uint32Array with valid ids \n  ${picocolors.italic(safeStringify(p, 100))}`,
@@ -305,18 +305,18 @@ export const validateSort = (def, field, orderInput) => {
         lang,
     };
 };
-export const validateAlias = (alias, path, def) => {
+export const validateAlias = (def, alias, path) => {
     const schema = def.schema;
     for (const k in alias) {
         if (typeof alias[k] === 'string') {
-            const p = path.join('.') + k;
+            const p = path ? `${path}.${k}` : k;
             const prop = schema.props[p];
             if (prop.typeIndex === ALIAS) {
                 return { def: prop, value: alias[k] };
             }
         }
         else if (typeof alias[k] === 'object') {
-            const propDef = validateAlias(alias[k], [...path, k], def);
+            const propDef = validateAlias(def, alias[k], path ? `${path}.${k}` : k);
             if (propDef) {
                 return propDef;
             }
@@ -438,7 +438,6 @@ export const EMPTY_SCHEMA_DEF = {
     ...createEmptyDef('_error', { props: {} }, {}),
     buf: new Uint8Array([]),
     propNames: new Uint8Array([]),
-    packed: new Uint8Array([]),
     idUint8: new Uint8Array([0, 0]),
     mainEmptyAllZeroes: true,
 };

package/dist/src/client/string.js

@@ -1,7 +1,5 @@
 import native from '../native.js';
-import { readUint32 } from './../utils.js';
-import makeTmpBuffer from './tmpBuffer.js';
-import { DECODER, ENCODER } from '../utils.js';
+import { readUint32, makeTmpBuffer, DECODER, ENCODER } from '@saulx/utils';
 const { getUint8Array: getTmpBuffer } = makeTmpBuffer(4096); // the usual page size?
 export const COMPRESSED = 1;
 export const NOT_COMPRESSED = 0;

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

@@ -1 +1 @@
-export declare const xxHash64: (buf: Uint8Array, target?: Uint8Array, index?: number) => Uint8Array;
+export declare const xxHash64: (buf: Uint8Array, target?: Uint8Array, index?: number) => Uint8Array<ArrayBufferLike>;

package/dist/src/index.d.ts

@@ -23,6 +23,7 @@ export declare class BasedDb {
         path: string;
         maxModifySize?: number;
         debug?: boolean | 'server';
+        saveIntervalInSeconds?: number;
     });
     create: DbClient['create'];
     copy: DbClient['copy'];

package/dist/src/index.js

@@ -4,6 +4,7 @@ import { DbServer } from './server/index.js';
 import { DbClient } from './client/index.js';
 import { wait } from '@saulx/utils';
 import { debugMode, debugServer } from './utils.js';
+import { BasedQueryResponse } from './client/query/BasedIterable.js';
 export * from './client/modify/modify.js';
 export { compress, decompress };
 export { ModifyCtx }; // TODO move this somewhere
@@ -31,12 +32,13 @@ export class BasedDb {
             }
         }
     }
-    #init({ path, maxModifySize }) {
+    #init({ path, maxModifySize, saveIntervalInSeconds, }) {
         this.fileSystemPath = path;
         this.maxModifySize = maxModifySize;
         const server = new DbServer({
             path,
             maxModifySize,
+            saveIntervalInSeconds,
             onSchemaChange(schema) {
                 client.putLocalSchema(schema);
             },
@@ -45,16 +47,42 @@ export class BasedDb {
             maxModifySize,
             hooks: {
                 subscribe(q, onData, onError) {
-                    console.warn('Subscription not supported without based-server!');
-                    return () => { };
+                    let timer;
+                    let prevChecksum;
+                    let lastLen = 0;
+                    let response;
+                    const get = async () => {
+                        const res = await server.getQueryBuf(q.buffer);
+                        if (!response) {
+                            response = new BasedQueryResponse(q.id, q.def, res, 0);
+                        }
+                        else {
+                            response.result = res;
+                            response.end = res.byteLength;
+                        }
+                        const checksum = response.checksum;
+                        if (lastLen != res.byteLength || checksum != prevChecksum) {
+                            onData(response);
+                            lastLen = res.byteLength;
+                            prevChecksum = checksum;
+                        }
+                        setTimeout(get, 200);
+                    };
+                    get();
+                    return () => {
+                        clearTimeout(timer);
+                    };
                 },
                 setSchema(schema, fromStart) {
                     return Promise.resolve(server.setSchema(schema, fromStart));
                 },
                 flushModify(buf) {
+                    const d = performance.now();
                     const offsets = server.modify(buf);
+                    const dbWriteTime = performance.now() - d;
                     return Promise.resolve({
                         offsets,
+                        dbWriteTime,
                     });
                 },
                 getQueryBuf(buf) {

package/dist/src/native.d.ts

@@ -6,7 +6,7 @@ declare const native: {
     intFromExternal(external: any): BigInt;
     modify: (data: Uint8Array, types: Uint8Array, dbCtx: any, dirtyBlocksOut: Float64Array) => any;
     getQueryBuf: (q: Uint8Array, dbCtx: any) => ArrayBuffer | null;
-    start: (id: number) => any;
+    start: () => any;
     stop: (dbCtx: any) => any;
     saveCommon: (path: string, dbCtx: any) => number;
     saveRange: (path: string, typeCode: number, start: number, end: number, dbCtx: any, hashOut: Uint8Array) => number;
@@ -22,6 +22,5 @@ declare const native: {
     destroySortIndex: (buf: Uint8Array, dbCtx: any) => any;
     xxHash64: (buf: Uint8Array, target: Uint8Array, index: number) => any;
     equals: (a: Uint8Array, b: Uint8Array) => boolean;
-    expire: (dbCtx: any) => void;
 };
 export default native;

package/dist/src/native.js

@@ -35,8 +35,8 @@ const native = {
         const x = db.getQueryBuf(dbCtx, q);
         return x;
     },
-    start: (id) => {
-        return db.start(id);
+    start: () => {
+        return db.start();
     },
     stop: (dbCtx) => {
         return db.stop(dbCtx);
@@ -93,9 +93,6 @@ const native = {
     equals: (a, b) => {
         return !!db.equals(a, b);
     },
-    expire: (dbCtx) => {
-        db.expire(dbCtx);
-    },
 };
 global.__basedDb__native__ = native;
 export default native;

package/dist/src/server/csmt/draw-dot.d.ts

@@ -1,2 +1,4 @@
 import { Csmt } from './index.js';
-export default function draw(csmt: Csmt): string;
+type DataFormatter<T> = (data: T) => string;
+export default function draw<T = any>(csmt: Csmt<T>, dataFormatter?: DataFormatter<T>): string;
+export {};

package/dist/src/server/csmt/draw-dot.js

@@ -2,7 +2,12 @@ import { encodeBase64 } from '@saulx/utils';
 function makeLabel(node) {
     return `${node.key}\n${encodeBase64(node.hash).substring(0, 5)}`;
 }
-export default function draw(csmt) {
+function wrapFormatter(dataFormatter, node) {
+    return `\n${dataFormatter(node.data).replace('"', '\\"')}`;
+}
+// This can be visualized with Graphviz dot.
+// Online: https://dreampuf.github.io/GraphvizOnline/?engine=dot
+export default function draw(csmt, dataFormatter) {
     const root = csmt.getRoot();
     const lines = [];
     const nodes = [];
@@ -12,7 +17,7 @@ export default function draw(csmt) {
         const left = node.left;
         const right = node.right;
         const isLeaf = !left && !right;
-        nodes.push(`n${cur} [label="${makeLabel(node)}"${isLeaf ? ' shape=box' : ''}];`);
+        nodes.push(`n${cur} [label="${makeLabel(node) + ((dataFormatter && node.data) ? wrapFormatter(dataFormatter, node) : '')}"${isLeaf ? ' shape=box' : ''}];`);
         if (cur > 0) {
             lines.push(`n${prev} -- n${cur}`);
         }

package/dist/src/server/csmt/match.d.ts

@@ -1,7 +1,7 @@
 type Predicate = (x: any) => boolean;
 type Func = (x: any) => any;
 declare const match: (x: any) => {
-    on: (pred: Predicate, fn: Func) => any;
+    on: (pred: Predicate, fn: Func) => /*elided*/ any;
     otherwise: (fn: Func) => any;
 };
 export default match;

package/dist/src/server/csmt/memebership-proof.d.ts

@@ -4,4 +4,4 @@ export declare enum Direction {
     Right = "R"
 }
 export type Proof = [TreeKey | null, TreeKey | null] | [TreeKey | Uint8Array, TreeKey | Direction][];
-export default function membershipProof(root: TreeNode | null, k: TreeKey): Proof;
+export default function membershipProof<T = any>(root: TreeNode<T> | null, k: TreeKey): Proof;

package/dist/src/server/csmt/tree-utils.d.ts

@@ -1,6 +1,6 @@
 import { TreeKey, TreeNode } from './types.js';
 export declare function distance(x: TreeKey, y: TreeKey): TreeKey;
-export declare function min(x: TreeNode | null, y: TreeNode | null): number;
-export declare function max(x: TreeNode | null, y: TreeNode | null): number;
-export declare function minInSubtree(node: TreeNode): TreeKey;
-export declare function maxInSubtree(node: TreeNode): TreeKey;
+export declare function min(x: TreeNode<any> | null, y: TreeNode<any> | null): TreeKey;
+export declare function max(x: TreeNode<any> | null, y: TreeNode<any> | null): TreeKey;
+export declare function minInSubtree(node: TreeNode<any>): TreeKey;
+export declare function maxInSubtree(node: TreeNode<any>): TreeKey;

package/dist/src/server/csmt/tree.d.ts

@@ -1,3 +1,3 @@
 import { Hash, Csmt } from './types.js';
 export declare function hashEq(a: Hash, b: Hash): boolean;
-export declare function createTree(createHash: () => any): Csmt;
+export declare function createTree<T>(createHash: () => any): Csmt<T>;

package/dist/src/server/csmt/tree.js

@@ -1,7 +1,7 @@
 import { TreeKeyNil } from './types.js';
 import { distance, min, max } from './tree-utils.js';
 import membershipProof from './memebership-proof.js';
-import { equals } from '../../utils.js';
+import { equals } from '@saulx/utils';
 export function hashEq(a, b) {
     return equals(a, b);
 }

package/dist/src/server/csmt/types.d.ts

@@ -2,24 +2,24 @@ import { Proof } from './memebership-proof.js';
 export type TreeKey = number;
 export declare const TreeKeyNil = 0;
 export type Hash = Uint8Array;
-export interface TreeNode {
+export interface TreeNode<T> {
     hash: Hash;
-    key: TreeKey;
-    data?: any;
-    left: TreeNode | null;
-    right: TreeNode | null;
+    key: TreeKey | null;
+    data?: T | null;
+    left: TreeNode<T> | null;
+    right: TreeNode<T> | null;
 }
 export type KeyHashPair = [TreeKey, Hash];
 export interface TreeDiff {
     left: KeyHashPair[];
     right: KeyHashPair[];
 }
-export interface Csmt {
+export interface Csmt<T> {
     emptyHash: Uint8Array;
     /**
      * Get the root node.
      */
-    getRoot: () => TreeNode | null;
+    getRoot: () => TreeNode<T> | null;
     /**
      * Insert a new key-hash pair.
      */
@@ -35,12 +35,12 @@ export interface Csmt {
     /**
      * Compute the diff between this and a given tree.
      */
-    diff: (tree: Csmt) => TreeDiff;
+    diff: (tree: Csmt<T>) => TreeDiff;
     /**
      * Provide a proof of membership if a key exist in the three;
      * Otherwise a proof of non-membership is returned.
      */
     membershipProof: (k: TreeKey) => Proof;
-    visitLeafNodes: (cb: (leaf: TreeNode) => void) => void;
-    search: (k: TreeKey) => TreeNode;
+    visitLeafNodes: (cb: (leaf: TreeNode<T>) => void) => void;
+    search: (k: TreeKey) => TreeNode<T>;
 }

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

@@ -1,5 +1,5 @@
 export default function createHash(): {
-    update: (buf: Uint8Array) => any;
+    update: (buf: Uint8Array) => /*elided*/ any;
     digest: (encoding?: "hex") => Uint8Array | string;
     reset: () => void;
 };

package/dist/src/server/dbHash.js

@@ -1,6 +1,6 @@
 // @ts-ignore
 import db from '../../../basedDbNative.cjs';
-import { bufToHex } from '../utils.js';
+import { bufToHex } from '@saulx/utils';
 export default function createHash() {
     const state = db.hashCreate();
     const hash = {

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

@@ -1,6 +1,7 @@
 import { LangName, StrictSchema } from '@based/schema';
 import { SchemaTypesParsed, SchemaTypesParsedById } from '@based/schema/def';
 import { createTree } from './csmt/index.js';
+import { CsmtNodeRange } from './tree.js';
 import { Worker, MessagePort } from 'node:worker_threads';
 import { TransformFns } from './migrate/index.js';
 import exitHook from 'exit-hook';
@@ -35,10 +36,10 @@ export declare class DbServer {
     schemaTypesParsedById: SchemaTypesParsedById;
     fileSystemPath: string;
     maxModifySize: number;
-    merkleTree: ReturnType<typeof createTree>;
+    merkleTree: ReturnType<typeof createTree<CsmtNodeRange>>;
     dirtyRanges: Set<number>;
     csmtHashFun: {
-        update: (buf: Uint8Array) => any;
+        update: (buf: Uint8Array) => /*elided*/ any;
         digest: (encoding?: "hex") => Uint8Array | string;
         reset: () => void;
     };
@@ -50,11 +51,14 @@ export declare class DbServer {
     stopped: boolean;
     onSchemaChange: OnSchemaChange;
     unlistenExit: ReturnType<typeof exitHook>;
-    constructor({ path, maxModifySize, onSchemaChange, debug, }: {
+    saveIntervalInSeconds?: number;
+    saveInterval?: NodeJS.Timeout;
+    constructor({ path, maxModifySize, onSchemaChange, debug, saveIntervalInSeconds, }: {
         path: string;
         maxModifySize?: number;
         onSchemaChange?: OnSchemaChange;
         debug?: boolean;
+        saveIntervalInSeconds?: number;
     });
     start(opts?: {
         clean?: boolean;
@@ -64,7 +68,7 @@ export declare class DbServer {
         forceFullDump?: boolean;
     }): Promise<void>;
     createCsmtHashFun: () => {
-        update: (buf: Uint8Array) => any;
+        update: (buf: Uint8Array) => /*elided*/ any;
         digest: (encoding?: "hex") => Uint8Array | string;
         reset: () => void;
     };

package/dist/src/server/index.js

@@ -5,7 +5,7 @@ import { dirname, join } from 'node:path';
 import { getPropType, langCodesMap, } from '@based/schema';
 import { updateTypeDefs, schemaToSelvaBuffer, } from '@based/schema/def';
 import { start } from './start.js';
-import { initCsmt, makeCsmtKey, makeCsmtKeyFromNodeId } from './tree.js';
+import { initCsmt, makeCsmtKey, makeCsmtKeyFromNodeId, } from './tree.js';
 import { save } from './save.js';
 import { Worker, MessageChannel } from 'node:worker_threads';
 import { fileURLToPath } from 'node:url';
@@ -17,6 +17,7 @@ export const WRITELOG_FILE = 'writelog.json';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const workerPath = join(__dirname, 'worker.js');
+const emptyUint8Array = new Uint8Array(0);
 class SortIndex {
     constructor(buf, dbCtxExternal) {
         this.buf = buf;
@@ -89,11 +90,14 @@ export class DbServer {
     stopped;
     onSchemaChange;
     unlistenExit;
-    constructor({ path, maxModifySize = 100 * 1e3 * 1e3, onSchemaChange, debug, }) {
+    saveIntervalInSeconds;
+    saveInterval;
+    constructor({ path, maxModifySize = 100 * 1e3 * 1e3, onSchemaChange, debug, saveIntervalInSeconds, }) {
         this.maxModifySize = maxModifySize;
         this.fileSystemPath = path;
         this.sortIndexes = {};
         this.onSchemaChange = onSchemaChange;
+        this.saveIntervalInSeconds = saveIntervalInSeconds;
         if (debug) {
             debugServer(this);
         }
@@ -380,12 +384,6 @@ export class DbServer {
             const def = this.schemaTypesParsedById[typeId];
             let offset = def.lastId - startId;
             if (offset < 0) {
-                console.log('-----------------');
-                console.log(def.type, {
-                    offset,
-                    serverId: def.lastId,
-                    clientId: startId,
-                });
                 offset = 0;
             }
             buf[i++] = offset;
@@ -397,7 +395,6 @@ export class DbServer {
             def.lastId = lastId + offset;
             offsets[typeId] = offset;
         }
-        // console.log('modify', this.processingQueries)
         if (this.processingQueries) {
             this.modifyQueue.push(new Uint8Array(buf));
         }
@@ -424,7 +421,8 @@ export class DbServer {
         const view = new DataView(buf.buffer, buf.byteOffset);
         while (i < end) {
             const key = view.getFloat64(i, true);
-            this.dirtyRanges.add(key);
+            // These node ranges may not actually exist
+            //this.dirtyRanges.add(key)
             i += 8;
         }
         this.#resizeModifyDirtyRanges();
@@ -436,6 +434,16 @@ export class DbServer {
             this.dirtyRanges.add(key);
         }
     }
+    #expire() {
+        this.#resizeModifyDirtyRanges();
+        native.modify(emptyUint8Array, emptyUint8Array, this.dbCtxExternal, this.modifyDirtyRanges);
+        for (let key of this.modifyDirtyRanges) {
+            if (key === 0) {
+                break;
+            }
+            this.dirtyRanges.add(key);
+        }
+    }
     addToQueryQueue(resolve, buf) {
         if (this.queryQueue.size === 16777216) {
             resolve(new Error('Query queue exceeded'));
@@ -477,7 +485,7 @@ export class DbServer {
                 // This will be more advanced - sometimes has indexes / sometimes not
             }
             if (!fromQueue) {
-                native.expire(this.dbCtxExternal);
+                this.#expire();
             }
             this.availableWorkerIndex =
                 (this.availableWorkerIndex + 1) % this.workers.length;
@@ -497,7 +505,7 @@ export class DbServer {
             if (this.queryQueue.size) {
                 const queryQueue = this.queryQueue;
                 this.queryQueue = new Map();
-                native.expire(this.dbCtxExternal);
+                this.#expire();
                 for (const [resolve, buf] of queryQueue) {
                     resolve(this.getQueryBuf(buf, true));
                 }
@@ -509,8 +517,15 @@ export class DbServer {
             return;
         }
         this.stopped = true;
-        clearTimeout(this.cleanupTimer);
         this.unlistenExit();
+        if (this.cleanupTimer) {
+            clearTimeout(this.cleanupTimer);
+            this.cleanupTimer = null;
+        }
+        if (this.saveInterval) {
+            clearInterval(this.saveInterval);
+            this.saveInterval = null;
+        }
         try {
             if (!noSave) {
                 await this.save();

package/dist/src/server/migrate/worker.js

@@ -48,6 +48,17 @@ else {
             if (props[path].typeIndex === REFERENCE ||
                 props[path].typeIndex === REFERENCES) {
                 include[i] = `${path}.id`;
+                if (props[path].edges) {
+                    for (const key in props[path].edges) {
+                        const prop = props[path].edges[key];
+                        if (prop.typeIndex === REFERENCE || prop.typeIndex === REFERENCES) {
+                            include.push(`${path}.${key}.id`);
+                        }
+                        else {
+                            include.push(`${path}.${key}`);
+                        }
+                    }
+                }
             }
         }
         map[id] = { type, include };

package/dist/src/server/save.js

@@ -5,7 +5,7 @@ import { join } from 'node:path';
 import { destructureCsmtKey, foreachBlock, foreachDirtyBlock, initCsmt, makeCsmtKey, specialBlock, } from './tree.js';
 import { WRITELOG_FILE } from './index.js';
 import { writeFileSync } from 'node:fs';
-import { bufToHex } from '../utils.js';
+import { bufToHex } from '@saulx/utils';
 const COMMON_SDB_FILE = 'common.sdb';
 const block_sdb_file = (typeId, start, end) => `${typeId}_${start}_${end}.sdb`;
 function saveRange(db, typeId, start, end, hashOut) {
@@ -14,7 +14,7 @@ function saveRange(db, typeId, start, end, hashOut) {
     const err = native.saveRange(path, typeId, start, end, db.dbCtxExternal, hashOut);
     if (err == -8) {
         // TODO ENOENT
-        return '';
+        return ''; // empty range
     }
     else if (err) {
         // TODO print the error string
@@ -61,18 +61,16 @@ export function save(db, sync = false, forceFullDump = false) {
     else {
         foreachDirtyBlock(db, (mtKey, typeId, start, end) => {
             const hash = new Uint8Array(16);
-            // TODO Don't save if empty
             const file = saveRange(db, typeId, start, end, hash);
             if (file === null) {
                 // The previous state should remain in the merkle tree for
                 // load and sync purposes.
                 return;
             }
-            else if (file.length === 0) {
-                // The range is empty
-            }
             else {
                 const oldLeaf = db.merkleTree.search(mtKey);
+                // If (file.length === 0) then the range is empty but that's fine,
+                // we'll keep them around for now to maintain the order of the tree.
                 if (oldLeaf) {
                     oldLeaf.data.file = file;
                     db.merkleTree.update(mtKey, hash);

package/dist/src/server/start.js

@@ -1,4 +1,3 @@
-import { stringHash } from '@saulx/hash';
 import { DbWorker, SCHEMA_FILE, WRITELOG_FILE } from './index.js';
 import native from '../native.js';
 import { rm, mkdir, readFile } from 'node:fs/promises';
@@ -10,16 +9,15 @@ import exitHook from 'exit-hook';
 import './worker.js';
 import { save } from './save.js';
 import { DEFAULT_BLOCK_CAPACITY } from '@based/schema/def';
-import { bufToHex, hexToBuf } from '../utils.js';
+import { bufToHex, hexToBuf } from '@saulx/utils';
 export async function start(db, opts) {
     const path = db.fileSystemPath;
-    const id = stringHash(path) >>> 0;
     const noop = () => { };
     if (opts?.clean) {
         await rm(path, { recursive: true, force: true }).catch(noop);
     }
     await mkdir(path, { recursive: true }).catch(noop);
-    db.dbCtxExternal = native.start(id);
+    db.dbCtxExternal = native.start();
     let writelog = null;
     try {
         writelog = JSON.parse((await readFile(join(path, WRITELOG_FILE))).toString());
@@ -36,11 +34,13 @@ export async function start(db, opts) {
             const dumps = writelog.rangeDumps[typeId];
             for (const dump of dumps) {
                 const fname = dump.file;
-                try {
-                    native.loadRange(join(path, fname), db.dbCtxExternal);
-                }
-                catch (e) {
-                    console.error(e.message);
+                if (fname?.length > 0) {
+                    try {
+                        native.loadRange(join(path, fname), db.dbCtxExternal);
+                    }
+                    catch (e) {
+                        console.error(e.message);
+                    }
                 }
             }
         }
@@ -63,7 +63,8 @@ export async function start(db, opts) {
             writelog?.types[def.id]?.blockCapacity || DEFAULT_BLOCK_CAPACITY;
         foreachBlock(db, def, (start, end, hash) => {
             const mtKey = makeCsmtKey(def.id, start);
-            const file = writelog.rangeDumps[def.id]?.find((v) => v.start === start)?.file || '';
+            const file = writelog.rangeDumps[def.id]?.find((v) => v.start === start)?.file ||
+                '';
             const data = {
                 file,
                 typeId: def.id,
@@ -71,7 +72,7 @@ export async function start(db, opts) {
                 end,
             };
             db.merkleTree.insert(mtKey, hash, data);
-        });
+        }, true);
     }
     if (writelog?.hash) {
         const oldHash = hexToBuf(writelog.hash);
@@ -101,5 +102,10 @@ export async function start(db, opts) {
             signals.forEach((sig) => process.off(sig, blockSig));
         });
     }
+    if (db.saveIntervalInSeconds > 0) {
+        db.saveInterval ??= setInterval(() => {
+            save(db);
+        }, db.saveIntervalInSeconds * 1e3);
+    }
 }
 //# sourceMappingURL=start.js.map

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

@@ -11,5 +11,5 @@ export declare const destructureCsmtKey: (key: number) => number[];
 export declare const makeCsmtKey: (typeId: number, start: number) => number;
 export declare const makeCsmtKeyFromNodeId: (typeId: number, blockCapacity: number, nodeId: number) => number;
 export declare function initCsmt(db: DbServer): {};
-export declare function foreachBlock(db: DbServer, def: SchemaTypeDef, cb: (start: number, end: number, hash: Uint8Array) => void): void;
+export declare function foreachBlock(db: DbServer, def: SchemaTypeDef, cb: (start: number, end: number, hash: Uint8Array) => void, includeEmptyBlocks?: boolean): void;
 export declare function foreachDirtyBlock(db: DbServer, cb: (mtKey: number, typeId: number, start: number, end: number) => void): Promise<void>;

package/dist/src/server/tree.js

@@ -38,13 +38,13 @@ export function initCsmt(db) {
     }
     return types;
 }
-export function foreachBlock(db, def, cb) {
+export function foreachBlock(db, def, cb, includeEmptyBlocks = false) {
     const step = def.blockCapacity;
     for (let start = 1; start <= def.lastId; start += step) {
         const end = start + step - 1;
         const hash = new Uint8Array(16);
         const res = native.getNodeRangeHash(def.id, start, end, hash, db.dbCtxExternal);
-        if (res) {
+        if (res || includeEmptyBlocks) {
             cb(start, end, hash);
         }
     }

package/dist/src/utils.d.ts

@@ -3,13 +3,3 @@ export declare const DECODER: TextDecoder;
 export declare const ENCODER: TextEncoder;
 export declare const debugMode: (target: any, getInfo?: any) => void;
 export declare const debugServer: (server: DbServer) => void;
-export declare const equals: (aB: Uint8Array, bB: Uint8Array) => boolean;
-export declare function concatUint8Arr(bufs: Uint8Array[], totalByteLength?: number): Uint8Array;
-export declare const bufToHex: (a: Uint8Array) => string;
-export declare const hexToBuf: (s: string) => Uint8Array;
-export declare const readDoubleLE: (val: Uint8Array, offset: number) => number;
-export declare const readFloatLE: (val: Uint8Array, offset: number) => number;
-export declare const readUint32: (val: Uint8Array, offset: number) => number;
-export declare const readInt32: (val: Uint8Array, offset: number) => number;
-export declare const readInt16: (val: Uint8Array, offset: number) => number;
-export declare const readUint16: (val: Uint8Array, offset: number) => number;