@based/db 0.0.70 → 0.1.0

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

@@ -1,6 +1,6 @@
 import { BasedDb, save } from '../../index.js';
 import { dirname, join } from 'path';
-import { Worker, MessageChannel, receiveMessageOnPort, } from 'node:worker_threads';
+import { Worker, MessageChannel, } from 'node:worker_threads';
 import native from '../../native.js';
 import { destructureTreeKey } from '../tree.js';
 import { foreachDirtyBlock } from '../blocks.js';
@@ -8,6 +8,7 @@ import { fileURLToPath } from 'url';
 import { setNativeSchema, setSchemaOnServer, writeSchemaFile, } from '../schema.js';
 import { setToAwake, waitUntilSleeping } from './utils.js';
 import { serialize } from '@based/schema';
+import { parse, parseRange, satisfies } from '@std/semver';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const workerPath = join(__dirname, 'worker.js');
@@ -28,10 +29,39 @@ const parseTransform = (transform) => {
     }
     return res;
 };
+const stripHooks = (schema) => {
+    const res = {};
+    for (const i in schema) {
+        if (i === 'types') {
+            res[i] = {};
+            for (const type in schema.types) {
+                const { hooks: _, ...rest } = schema.types[type];
+                res[i][type] = rest;
+            }
+        }
+        else {
+            res[i] = schema[i];
+        }
+    }
+    return res;
+};
 export const migrate = async (server, fromSchema, toSchema, transform) => {
     const migrationId = toSchema.hash;
     server.migrating = migrationId;
     server.emit('info', `migrating schema ${migrationId}`);
+    fromSchema = stripHooks(fromSchema);
+    toSchema = stripHooks(toSchema);
+    if (!transform && toSchema.migrations?.length) {
+        const fromVersion = fromSchema.version || '0.0.0';
+        transform = {};
+        for (const { migrate, version } of toSchema.migrations) {
+            if (satisfies(parse(fromVersion), parseRange(version))) {
+                for (const type in migrate) {
+                    transform[type] = migrate[type];
+                }
+            }
+        }
+    }
     let killed = false;
     const abort = () => {
         if (killed) {
@@ -77,11 +107,9 @@ export const migrate = async (server, fromSchema, toSchema, transform) => {
             to: toAddress,
             fromSchema: serialize(fromSchema, {
                 stripMetaInformation: true,
-                stripTransform: true,
             }),
             toSchema: serialize(toSchema, {
                 stripMetaInformation: true,
-                stripTransform: true,
             }),
             channel: port2,
             workerState,
@@ -141,22 +169,9 @@ export const migrate = async (server, fromSchema, toSchema, transform) => {
         await Promise.all([tmpDb.destroy(), worker.terminate()]);
         return;
     }
-    let msg;
-    let schemaTypesParsed;
-    while ((msg = receiveMessageOnPort(port1))) {
-        schemaTypesParsed = msg.message;
-    }
     server.dbCtxExternal = toCtx;
     server.sortIndexes = {};
-    // ----------------MAKE NICE THIS------------------
-    // pass last node IDS { type: lastId }
     setSchemaOnServer(server, toSchema);
-    for (const key in schemaTypesParsed) {
-        // maybe only send the lastId
-        const def = server.schemaTypesParsed[key];
-        def.lastId = schemaTypesParsed[key].lastId;
-    }
-    // -----------------------------------------
     tmpDb.server.dbCtxExternal = fromCtx;
     // TODO makes this SYNC
     const promises = [server.ioWorker, ...server.workers].map((worker) => worker.updateCtx(toAddress));

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

@@ -2,7 +2,6 @@ import { isMainThread, receiveMessageOnPort, workerData, } from 'node:worker_thr
 import native from '../../native.js';
 import { BasedDb } from '../../index.js';
 import { REFERENCE, REFERENCES } from '@based/schema/def';
-import { isTypedArray } from 'node:util/types';
 import { setSchemaOnServer } from '../schema.js';
 import { setToSleep } from './utils.js';
 import { setLocalClientSchema } from '../../client/setLocalClientSchema.js';
@@ -14,32 +13,10 @@ else if (workerData?.isDbMigrateWorker) {
     const { from, to, fromSchema, toSchema, channel, workerState, transformFns } = workerData;
     const fromCtx = native.externalFromInt(from);
     const toCtx = native.externalFromInt(to);
-    // worker ctx init - maybe instead of this just add it on native
-    // instead of here just do this in native.js
-    native.workerCtxInit();
+    native.createThreadCtx(fromCtx, native.getThreadId());
+    native.createThreadCtx(toCtx, native.getThreadId());
     const fromDb = new BasedDb({ path: null });
     const toDb = new BasedDb({ path: null });
-    const cp = (obj) => {
-        let copy;
-        for (const key in obj) {
-            const val = obj[key];
-            if (typeof val === 'number') {
-                // only copy numbers
-                copy ??= Array.isArray(obj) ? [] : {};
-                copy[key] = val;
-            }
-            else if (typeof val === 'object' &&
-                val !== null &&
-                !isTypedArray(val)) {
-                const res = cp(val);
-                if (res) {
-                    copy ??= Array.isArray(obj) ? [] : {};
-                    copy[key] = cp(val);
-                }
-            }
-        }
-        return copy;
-    };
     fromDb.server.dbCtxExternal = fromCtx;
     toDb.server.dbCtxExternal = toCtx;
     setSchemaOnServer(fromDb.server, deSerialize(fromSchema));
@@ -115,8 +92,6 @@ else if (workerData?.isDbMigrateWorker) {
             }
             await toDb.drain();
             native.membarSyncWrite();
-            // WE ARE ONLY GOING TO SEND { type: lastNodeId }
-            channel.postMessage(cp(toDb.server.schemaTypesParsed));
             setToSleep(workerState);
         }
     }

package/dist/src/server/save.js

@@ -2,17 +2,18 @@ import native from '../native.js';
 import { isMainThread } from 'node:worker_threads';
 import { writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import { VerifTree, destructureTreeKey, } from './tree.js';
+import { VerifTree, destructureTreeKey } from './tree.js';
 import { saveBlock, foreachBlock, foreachDirtyBlock, saveBlocks, } from './blocks.js';
 import { writeFileSync } from 'node:fs';
-import { bufToHex } from '@saulx/utils';
+import { bufToHex } from '@based/utils';
 import { COMMON_SDB_FILE, WRITELOG_FILE } from '../types.js';
 function hasPartialTypes(db) {
-    let res = false;
-    for (let id in db.schemaTypesParsedById) {
-        res = res || db.schemaTypesParsedById[id].partial;
+    for (const id in db.schemaTypesParsedById) {
+        if (db.schemaTypesParsedById[id].partial) {
+            return true;
+        }
     }
-    return res;
+    return false;
 }
 function inhibitSave(db, { skipDirtyCheck, forceFullDump, skipMigrationCheck }) {
     // RFE isMainThread needed??
@@ -100,8 +101,9 @@ export function saveSync(db, opts = {}) {
     }
 }
 export async function save(db, opts = {}) {
-    if (inhibitSave(db, opts))
+    if (inhibitSave(db, opts)) {
         return;
+    }
     let ts = Date.now();
     db.saveInProgress = true;
     try {
@@ -138,7 +140,7 @@ export async function save(db, opts = {}) {
                 blocks.push({
                     filepath,
                     typeId,
-                    start
+                    start,
                 });
             });
         }

package/dist/src/server/schema.js

@@ -1,13 +1,15 @@
 import { schemaToSelvaBuffer, updateTypeDefs } from '@based/schema/def';
-import { deepCopy, writeUint64 } from '@saulx/utils';
+import { deepCopy } from '@based/utils';
 import { getPropType, serialize } from '@based/schema';
 import { join } from 'node:path';
 import { writeFile } from 'node:fs/promises';
 import native from '../native.js';
-import { makeTreeKey } from './tree.js';
 import { SCHEMA_FILE } from '../types.js';
 import { saveSync } from './save.js';
-import { hash } from '@saulx/hash';
+import { hash } from '@based/hash';
+import { writeCreate } from '../client/modify/create/index.js';
+import { Ctx } from '../client/modify/Ctx.js';
+import { consume } from '../client/modify/drain.js';
 export const setSchemaOnServer = (server, schema) => {
     const { schemaTypesParsed, schemaTypesParsedById } = updateTypeDefs(schema);
     server.schema = schema;
@@ -15,12 +17,14 @@ export const setSchemaOnServer = (server, schema) => {
     server.schemaTypesParsedById = schemaTypesParsedById;
 };
 export const writeSchemaFile = async (server, schema) => {
-    const schemaFilePath = join(server.fileSystemPath, SCHEMA_FILE);
-    try {
-        await writeFile(schemaFilePath, serialize(schema));
-    }
-    catch (err) {
-        throw new Error(`Error writing schema to a file path ${schemaFilePath}}`);
+    if (server.fileSystemPath) {
+        const schemaFilePath = join(server.fileSystemPath, SCHEMA_FILE);
+        try {
+            await writeFile(schemaFilePath, serialize(schema));
+        }
+        catch (err) {
+            throw new Error(`Error writing schema to a file path ${schemaFilePath}}`);
+        }
     }
 };
 export const setNativeSchema = (server, schema) => {
@@ -37,23 +41,11 @@ export const setNativeSchema = (server, schema) => {
     }
     // Insert a root node
     if (schema.types._root) {
-        // TODO fix server 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 = makeTreeKey(1, 1);
-        const buf = new Uint8Array(8 + data.length + 2 + 8 + 4);
-        const view = new DataView(buf.buffer, 0, buf.byteLength);
-        // set schema hash
-        writeUint64(buf, server.schema.hash, 0);
-        // add content
-        buf.set(data, 8);
-        // add typesLen
-        view.setFloat64(8 + data.length, 0, true);
-        // add dirty key
-        view.setFloat64(8 + data.length + 2, blockKey, true);
-        // add dataLen
-        view.setUint32(buf.length - 4, data.length, true);
+        const tmpArr = new Uint8Array(new ArrayBuffer(1e3, { maxByteLength: 10e3 }));
+        const tmpCtx = new Ctx(schema.hash, tmpArr);
+        writeCreate(tmpCtx, server.schemaTypesParsed._root, {}, null);
+        const buf = consume(tmpCtx);
         server.modify(buf);
-        //server.verifTree = new VerifTree(.schemaTypesParsed)
     }
     server.verifTree.updateTypes(server.schemaTypesParsed);
     if (server.fileSystemPath) {

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

@@ -2,6 +2,7 @@ import { DbServer } from './index.js';
 export type StartOpts = {
     clean?: boolean;
     hosted?: boolean;
+    noLoadDumps?: boolean;
     delayInMs?: number;
     queryThreads?: number;
 };

package/dist/src/server/start.js

@@ -10,7 +10,7 @@ import exitHook from 'exit-hook';
 import { save, saveSync } from './save.js';
 import { deSerialize } from '@based/schema';
 import { BLOCK_CAPACITY_DEFAULT } from '@based/schema/def';
-import { bufToHex, equals, hexToBuf, wait } from '@saulx/utils';
+import { bufToHex, equals, hexToBuf, wait } from '@based/utils';
 import { SCHEMA_FILE, WRITELOG_FILE, SCHEMA_FILE_DEPRECATED } from '../types.js';
 import { setSchemaOnServer } from './schema.js';
 function startWorkers(db, opts) {
@@ -34,6 +34,11 @@ export async function start(db, opts) {
     let partials = []; // Blocks that exists but were not loaded [key, hash]
     try {
         writelog = JSON.parse((await readFile(join(path, WRITELOG_FILE))).toString());
+    }
+    catch (err) {
+        // No dump
+    }
+    if (writelog) {
         // Load the common dump
         try {
             native.loadCommon(join(path, writelog.commonDump), db.dbCtxExternal);
@@ -42,6 +47,7 @@ export async function start(db, opts) {
             console.error(e.message);
             throw e;
         }
+        // Load schema
         const schema = await readFile(join(path, SCHEMA_FILE)).catch(noop);
         if (schema) {
             const s = deSerialize(schema);
@@ -53,14 +59,14 @@ export async function start(db, opts) {
                 setSchemaOnServer(db, JSON.parse(schemaJson.toString()));
             }
         }
-        // Load all range dumps
+        // Load block dumps
         for (const typeId in writelog.rangeDumps) {
             const dumps = writelog.rangeDumps[typeId];
             const def = db.schemaTypesParsedById[typeId];
-            for (const dump of dumps) {
-                const fname = dump.file;
-                if (fname?.length > 0) {
-                    if (!def.partial) {
+            if (!def.partial && !opts?.noLoadDumps) {
+                for (const dump of dumps) {
+                    const fname = dump.file;
+                    if (fname?.length > 0) {
                         try {
                             // Can't use loadBlock() yet because verifTree is not avail
                             native.loadBlock(join(path, fname), db.dbCtxExternal);
@@ -69,7 +75,12 @@ export async function start(db, opts) {
                             console.error(e.message);
                         }
                     }
-                    else {
+                }
+            }
+            else {
+                for (const dump of dumps) {
+                    const fname = dump.file;
+                    if (fname?.length > 0) {
                         partials.push([
                             makeTreeKey(def.id, dump.start),
                             hexToBuf(dump.hash),
@@ -79,9 +90,6 @@ export async function start(db, opts) {
             }
         }
     }
-    catch (err) {
-        // TODO In some cases we really should give up!
-    }
     db.verifTree = new VerifTree(db.schemaTypesParsed);
     for (const { typeId } of db.verifTree.types()) {
         const def = db.schemaTypesParsedById[typeId];

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

@@ -4,7 +4,15 @@ export declare const makeTreeKey: (typeId: number, start: number) => number;
 export declare const nodeId2Start: (blockCapacity: number, nodeId: number) => number;
 export declare const makeTreeKeyFromNodeId: (typeId: number, blockCapacity: number, nodeId: number) => number;
 type Hash = Uint8Array;
+/**
+ * Block state.
+ * Type and a node id range.
+ */
 export type VerifBlock = {
+    /**
+     * key = typeId + startNodeId
+     * Made with makeTreeKey(t, i) and can be destructured with destructureTreeKey(k).
+     */
     key: number;
     /**
      * Last acquired hash of the block.
@@ -21,10 +29,22 @@ export type VerifBlock = {
      */
     loadPromise: null | Promise<void>;
 };
+/**
+ * Container for a whole type.
+ */
+type VerifType = {
+    typeId: number; /*!< typeId as in the schema. */
+    blockCapacity: number; /*!< Max number of nodes per block. */
+    blocks: VerifBlock[];
+};
+/**
+ * An object that keeps track of all blocks of nodes existing in the database.
+ */
 export declare class VerifTree {
     #private;
     constructor(schemaTypesParsed: Record<string, SchemaTypeDef>);
     types(): Generator<any, void, unknown>;
+    blocks(type: VerifType): Generator<VerifBlock, void, unknown>;
     foreachBlock(cb: (block: VerifBlock) => void): void;
     get hash(): Uint8Array;
     update(key: number, hash: Hash, inmem?: boolean): void;

package/dist/src/server/tree.js

@@ -5,12 +5,15 @@ export const destructureTreeKey = (key) => [
 ];
 export const makeTreeKey = (typeId, start) => typeId * 4294967296 + start;
 export const nodeId2Start = (blockCapacity, nodeId) => ((nodeId - +!(nodeId % blockCapacity)) / blockCapacity) | 0;
-const nodeId2BlockI = (nodeId, blockCapacity) => ((nodeId - 1) - ((nodeId - 1) % blockCapacity)) / blockCapacity;
+const nodeId2BlockI = (nodeId, blockCapacity) => (nodeId - 1 - ((nodeId - 1) % blockCapacity)) / blockCapacity;
 export const makeTreeKeyFromNodeId = (typeId, blockCapacity, nodeId) => {
     const tmp = nodeId - +!(nodeId % blockCapacity);
     return typeId * 4294967296 + ((tmp / blockCapacity) | 0) * blockCapacity + 1;
 };
 const HASH_SIZE = 16;
+/**
+ * An object that keeps track of all blocks of nodes existing in the database.
+ */
 export class VerifTree {
     #types;
     #h = createDbHash();
@@ -36,6 +39,12 @@ export class VerifTree {
             yield this.#types[k];
         }
     }
+    *blocks(type) {
+        const { blocks } = type;
+        for (const block of blocks) {
+            yield block;
+        }
+    }
     foreachBlock(cb) {
         for (const k of Object.keys(this.#types)) {
             const { blocks } = this.#types[k];
@@ -57,7 +66,13 @@ export class VerifTree {
             throw new Error(`type ${typeId} not found`);
         }
         const blockI = nodeId2BlockI(start, type.blockCapacity);
-        const block = type.blocks[blockI] ?? (type.blocks[blockI] = Object.preventExtensions({ key, hash, inmem, loadPromise: null }));
+        const block = type.blocks[blockI] ??
+            (type.blocks[blockI] = Object.preventExtensions({
+                key,
+                hash,
+                inmem,
+                loadPromise: null,
+            }));
         block.hash = hash;
         block.inmem = inmem;
     }

package/dist/src/server/workers/DbWorker.d.ts

@@ -1,6 +1,7 @@
 import { MessagePort } from 'node:worker_threads';
 import { DbServer } from '../index.js';
 export declare abstract class DbWorker {
+    #private;
     constructor(address: BigInt, db: DbServer, onExit: (code: number) => void, workerName: string);
     protected db: DbServer;
     protected channel: MessagePort;

package/dist/src/server/workers/DbWorker.js

@@ -1,9 +1,11 @@
 import { MessageChannel, Worker } from 'node:worker_threads';
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
+import native from '../../native.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 export class DbWorker {
+    #threadId;
     constructor(address, db, onExit, workerName) {
         const { port1, port2 } = new MessageChannel();
         this.db = db;
@@ -18,7 +20,10 @@ export class DbWorker {
         });
         this.readyPromise = new Promise((resolve) => {
             const onReady = (msg) => {
-                if (msg === 'READY') {
+                if (msg?.status === 'READY') {
+                    // TODO Also call native.destroyThreadCtx() somewhere
+                    this.#threadId = msg.threadId;
+                    native.createThreadCtx(db.dbCtxExternal, this.#threadId);
                     this.worker.off('message', onReady);
                     resolve(true);
                 }
@@ -67,6 +72,8 @@ export class DbWorker {
         return new Promise(this.callback);
     }
     updateCtx(address) {
+        const ctx = native.externalFromInt(address);
+        native.createThreadCtx(ctx, this.#threadId);
         return this.call(address);
     }
 }

package/dist/src/server/workers/io_worker.js

@@ -1,5 +1,5 @@
 import { registerMsgHandler } from './worker.js';
-import { writeInt32 } from '@saulx/utils';
+import { writeInt32 } from '@based/utils';
 import native from '../../native.js';
 function loadBlock(dbCtx, filepath) {
     native.loadBlock(filepath, dbCtx);

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

@@ -2,14 +2,12 @@ import { isMainThread, parentPort, workerData } from 'node:worker_threads';
 import { nextTick } from 'node:process';
 import native from '../../native.js';
 let dbCtx;
-let wCtx; // This must be held until the worker exits otherwise the ctx will be autofreed instantly
 if (isMainThread) {
     console.warn(`running a worker in the mainthread - incorrect`);
 }
 else if (workerData?.isDbWorker) {
     let { address } = workerData;
     dbCtx = native.externalFromInt(address);
-    wCtx = native.workerCtxInit();
 }
 else {
     console.info('incorrect worker db query');
@@ -24,7 +22,14 @@ export function registerMsgHandler(onMsg) {
             if (typeof msg === 'bigint') {
                 if (msg === 0n) {
                     // terminate
-                    nextTick(() => typeof self === 'undefined' ? process.exit() : self.close());
+                    nextTick(() => {
+                        if (typeof self === 'undefined') {
+                            process.exit();
+                        }
+                        else {
+                            self.close();
+                        }
+                    });
                     channel.postMessage(null);
                 }
                 else {
@@ -44,6 +49,6 @@ export function registerMsgHandler(onMsg) {
         }
     };
     channel.on('message', handleMsg);
-    parentPort.postMessage('READY');
+    parentPort.postMessage({ status: 'READY', threadId: native.getThreadId() });
 }
 //# sourceMappingURL=worker.js.map

package/dist/src/table.d.ts

@@ -0,0 +1,4 @@
+export declare function formatTable(header: string[], align: Array<'l' | 'r' | 'c' | '.'>, blocks: {
+    name: string;
+    rows: (string | number)[][];
+}[], hsep?: string): string;

package/dist/src/table.js

@@ -0,0 +1,97 @@
+import { styleText } from 'node:util';
+function dotindex(c) {
+    const m = /\.[^.]*$/.exec(c);
+    return m ? m.index + 1 : c.length;
+}
+function strlen(str) {
+    return str.replace(/\u001b[^m]*m/g, '').length;
+}
+function table(rows_, opts) {
+    if (!opts)
+        opts = {};
+    const hsep = opts.hsep;
+    const align = opts.align || [];
+    const dotsizes = rows_.reduce((acc, row) => {
+        row.forEach((c, ix) => {
+            const n = align[ix] == '.' ? dotindex(c) : 0;
+            if (!acc[ix] || n > acc[ix])
+                acc[ix] = n;
+        });
+        return acc;
+    }, []);
+    const rows = rows_.map((row) => {
+        return row.map((c_, ix) => {
+            const c = String(c_);
+            if (align[ix] === '.') {
+                const index = dotindex(c);
+                const size = dotsizes[ix] + (/\./.test(c) ? 1 : 2) - (strlen(c) - index);
+                return c + Array(size).join(' ');
+            }
+            else
+                return c;
+        });
+    });
+    const sizes = rows.reduce((acc, row) => {
+        row.forEach((c, ix) => {
+            const n = strlen(c);
+            if (!acc[ix] || n > acc[ix])
+                acc[ix] = n;
+        });
+        return acc;
+    }, []);
+    return rows
+        .map((row) => {
+        return row
+            .map((c, ix) => {
+            const n = sizes[ix] - strlen(c) || 0;
+            const s = Array(Math.max(n + 1, 1)).join(' ');
+            if (align[ix] === 'r' || align[ix] === '.') {
+                return s + c;
+            }
+            if (align[ix] === 'c') {
+                return (Array(Math.ceil(n / 2 + 1)).join(' ') +
+                    c +
+                    Array(Math.floor(n / 2 + 1)).join(' '));
+            }
+            return c + s;
+        })
+            .join(hsep)
+            .replace(/\s+$/, '');
+    })
+        .join('\n');
+}
+export function formatTable(header, align, blocks, hsep = '    ') {
+    const nrCols = header.length;
+    const padding = [];
+    let out = '\n';
+    for (let i = 0; i < nrCols; i++) {
+        padding[i] = blocks.reduce((acc, block) => {
+            const maxLen = Math.max(...block.rows.map((row) => strlen(`${row[i]}`)));
+            return Math.max(acc, Math.ceil(maxLen / 8));
+        }, 1);
+    }
+    for (const block of blocks) {
+        if (block.name) {
+            out += `${styleText('bold', block.name)}\n`;
+        }
+        // @ts-ignore
+        const rows = [header.map((s) => styleText('dim', s))].concat(block.rows);
+        if (rows.length > 0) {
+            rows[0][0] = ` ${rows[0][0]}`;
+            for (let i = 1; i < rows.length; i++) {
+                const row = rows[i].slice(0);
+                row[0] = ` ${row[0]}`;
+                for (let j = 0; j < nrCols; j++) {
+                    const col = `${row[j]}`;
+                    const al = align[j] || 'l';
+                    const pad = padding[j] > 1 ? ' '.repeat(padding[j] * 8 - strlen(col)) : '';
+                    rows[i][j] = al === 'l' ? col + pad : pad + col;
+                }
+            }
+            out += table(rows, { align, hsep });
+        }
+        out += '\n\n';
+    }
+    return out.slice(0, -1);
+}
+//# sourceMappingURL=table.js.map

package/dist/src/types.d.ts

@@ -3,7 +3,7 @@ export declare const SCHEMA_FILE = "schema.bin";
 export declare const WRITELOG_FILE = "writelog.json";
 export declare const COMMON_SDB_FILE = "common.sdb";
 export type BasedDbOpts = {
-    path: string;
+    path: string | null;
     maxModifySize?: number;
     debug?: boolean | 'server' | 'client';
     saveIntervalInSeconds?: number;