@based/db 0.0.70 → 0.1.0

package/dist/src/client/string.js

@@ -1,80 +1,51 @@
 import native from '../native.js';
-import { readUint32, makeTmpBuffer, DECODER, ENCODER } from '@saulx/utils';
+import { makeTmpBuffer, ENCODER, writeUint32 } from '@based/utils';
+import { COMPRESSED, NOT_COMPRESSED } from '@based/protocol/db-read';
+import { resize } from './modify/resize.js';
 const { getUint8Array: getTmpBuffer } = makeTmpBuffer(4096); // the usual page size?
-export const COMPRESSED = 1;
-export const NOT_COMPRESSED = 0;
-export const write = (buf, value, offset, noCompression, lang) => {
+export const write = (ctx, value, offset, noCompression, lang) => {
+    const buf = ctx.array;
     value = value.normalize('NFKD');
     buf[offset] = lang || 0;
     const { written: l } = ENCODER.encodeInto(value, buf.subarray(offset + 2));
     let crc = native.crc32(buf.subarray(offset + 2, offset + 2 + l));
     // 50 len maybe if lvl 1
     if (value.length > 200 && !noCompression) {
-        buf.copyWithin(offset + 6 + l, offset + 2, offset + 2 + l);
+        const insertPos = offset + 6 + l;
+        const startPos = offset + 2;
+        const endPos = offset + 2 + l;
+        const willEnd = insertPos + l;
+        resize(ctx, willEnd);
+        buf.copyWithin(insertPos, startPos, endPos);
         const size = native.compress(buf, offset + 6, l);
         if (size === 0) {
+            resize(ctx, l + 6);
             buf[offset + 1] = NOT_COMPRESSED;
             ENCODER.encodeInto(value, buf.subarray(offset + 2));
-            buf[offset + l + 2] = crc;
-            buf[offset + l + 3] = crc >>>= 8;
-            buf[offset + l + 4] = crc >>>= 8;
-            buf[offset + l + 5] = crc >>>= 8;
+            writeUint32(buf, crc, offset + l + 2);
             return l + 6;
         }
         else {
+            resize(ctx, size + 10);
             let len = l;
             buf[offset + 1] = COMPRESSED;
-            buf[offset + 2] = len;
-            buf[offset + 3] = len >>>= 8;
-            buf[offset + 4] = len >>>= 8;
-            buf[offset + 5] = len >>>= 8;
-            buf[offset + size + 6] = crc;
-            buf[offset + size + 7] = crc >>>= 8;
-            buf[offset + size + 8] = crc >>>= 8;
-            buf[offset + size + 9] = crc >>>= 8;
+            writeUint32(buf, len, offset + 2);
+            writeUint32(buf, crc, offset + size + 6);
             return size + 10;
         }
     }
     else {
         buf[offset + 1] = NOT_COMPRESSED;
-        buf[offset + l + 2] = crc;
-        buf[offset + l + 3] = crc >>>= 8;
-        buf[offset + l + 4] = crc >>>= 8;
-        buf[offset + l + 5] = crc >>>= 8;
+        writeUint32(buf, crc, offset + l + 2);
         return l + 6;
     }
 };
 export const compress = (str) => {
     const len = ENCODER.encode(str).byteLength;
     const tmpCompressBlock = getTmpBuffer(len * 3);
-    const l = write(tmpCompressBlock, str, 0, false);
+    const l = write({ array: tmpCompressBlock }, str, 0, false);
     const nBuffer = new Uint8Array(l);
     nBuffer.set(tmpCompressBlock.subarray(0, l));
     return nBuffer;
 };
-export const decompress = (val) => {
-    return read(val, 0, val.length, false);
-};
-export const read = (val, offset, len, stripCrc32) => {
-    const type = val[offset + 1];
-    if (type == COMPRESSED) {
-        const origSize = readUint32(val, offset + 2);
-        const newBuffer = getTmpBuffer(origSize);
-        // Browser fallback required for this
-        native.decompress(val, newBuffer, offset + 6, stripCrc32 ? len - 2 : len - 6);
-        return DECODER.decode(newBuffer);
-    }
-    else if (type == NOT_COMPRESSED) {
-        if (stripCrc32) {
-            return DECODER.decode(val.subarray(offset + 2, len + offset));
-        }
-        else {
-            return DECODER.decode(val.subarray(offset + 2, len + offset - 4));
-        }
-    }
-    return '';
-};
-export const readUtf8 = (val, offset, len) => {
-    return DECODER.decode(val.subarray(offset, len + offset));
-};
 //# sourceMappingURL=string.js.map

package/dist/src/hooks.d.ts

@@ -1,11 +1,10 @@
-import { StrictSchema } from '@based/schema';
+import { StrictSchema, MigrateFns } from '@based/schema';
 import { BasedDbQuery } from './client/query/BasedDbQuery.js';
 import { OnClose, OnData, OnError } from './client/query/subscription/types.js';
 import { DbServer } from './server/index.js';
-import { TransformFns } from './server/migrate/index.js';
 import { DbSchema, SchemaChecksum } from './schema.js';
 export type DbClientHooks = {
-    setSchema(schema: StrictSchema, transformFns?: TransformFns): Promise<SchemaChecksum>;
+    setSchema(schema: StrictSchema, transformFns?: MigrateFns): Promise<SchemaChecksum>;
     flushModify(buf: Uint8Array): Promise<{
         offsets: Record<number, number>;
         dbWriteTime?: number;

package/dist/src/hooks.js

@@ -31,8 +31,8 @@ export const getDefaultHooks = (server, subInterval = 200) => {
                 killed = true;
             };
         },
-        setSchema(schema) {
-            return server.setSchema(schema);
+        setSchema(schema, transformFns) {
+            return server.setSchema(schema, transformFns);
         },
         subscribeSchema(setSchema) {
             if (server.schema) {
@@ -43,13 +43,18 @@ export const getDefaultHooks = (server, subInterval = 200) => {
             });
         },
         flushModify(buf) {
-            const d = performance.now();
-            const offsets = server.modify(buf);
-            const dbWriteTime = performance.now() - d;
-            return Promise.resolve({
-                offsets,
-                dbWriteTime,
-            });
+            try {
+                const d = performance.now();
+                const offsets = server.modify(buf);
+                const dbWriteTime = performance.now() - d;
+                return Promise.resolve({
+                    offsets,
+                    dbWriteTime,
+                });
+            }
+            catch (e) {
+                return Promise.reject(e);
+            }
         },
         getQueryBuf(buf) {
             return Promise.resolve(server.getQueryBuf(buf));

package/dist/src/index.d.ts

@@ -1,13 +1,11 @@
-import { compress, decompress } from './client/string.js';
-import { ModifyCtx } from './client/flushModify.js';
+import { compress } from './client/string.js';
 import { DbServer } from './server/index.js';
 import { DbClient } from './client/index.js';
 import { getDefaultHooks } from './hooks.js';
 import { Emitter } from './shared/Emitter.js';
 import { BasedDbOpts } from './types.js';
-export * from './client/modify/modify.js';
+import { decompress } from '@based/protocol/db-read';
 export { compress, decompress };
-export { ModifyCtx };
 export { DbClient, DbServer };
 export { xxHash64 } from './client/xxHash64.js';
 export { crc32 } from './client/crc32.js';
@@ -15,7 +13,7 @@ export { default as createHash } from './server/dbHash.js';
 export * from './utils.js';
 export * from './client/query/query.js';
 export * from './client/query/BasedDbQuery.js';
-export * from './client/query/BasedIterable.js';
+export * from './client/query/BasedQueryResponse.js';
 export * from './server/save.js';
 export * from './hooks.js';
 export { getDefaultHooks, BasedDbOpts };

package/dist/src/index.js

@@ -1,14 +1,12 @@
-import { compress, decompress } from './client/string.js';
-import { ModifyCtx } from './client/flushModify.js';
+import { compress } from './client/string.js';
 import { DbServer } from './server/index.js';
 import { DbClient } from './client/index.js';
-import { wait } from '@saulx/utils';
+import { wait } from '@based/utils';
 import { debugMode, debugServer } from './utils.js';
 import { getDefaultHooks } from './hooks.js';
 import { Emitter } from './shared/Emitter.js';
-export * from './client/modify/modify.js';
+import { decompress } from '@based/protocol/db-read';
 export { compress, decompress };
-export { ModifyCtx };
 export { DbClient, DbServer };
 export { xxHash64 } from './client/xxHash64.js';
 export { crc32 } from './client/crc32.js';
@@ -16,7 +14,7 @@ export { default as createHash } from './server/dbHash.js';
 export * from './utils.js';
 export * from './client/query/query.js';
 export * from './client/query/BasedDbQuery.js';
-export * from './client/query/BasedIterable.js';
+export * from './client/query/BasedQueryResponse.js';
 export * from './server/save.js';
 export * from './hooks.js';
 export { getDefaultHooks };

package/dist/src/native.d.ts

@@ -1,6 +1,7 @@
 declare const native: {
-    threadCtx: any;
-    workerCtxInit: () => void;
+    getThreadId: () => BigInt;
+    createThreadCtx: (dbCtx: any, threadId: BigInt) => void;
+    destroyThreadCtx: (dbCtx: any, threadId: BigInt) => void;
     externalFromInt(address: BigInt): any;
     intFromExternal(external: any): BigInt;
     modify: (data: Uint8Array, types: Uint8Array, dbCtx: any, dirtyBlocksOut: Float64Array) => any;

package/dist/src/native.js

@@ -4,21 +4,22 @@ import db from '../../basedDbNative.cjs';
 const DECODER = new TextDecoder('utf-8');
 const ENCODER = new TextEncoder();
 const selvaIoErrlog = new Uint8Array(256);
-var compressor = db.createCompressor(); // put on threadCtx
+var compressor = db.createCompressor();
 var decompressor = db.createDecompressor();
 function SelvaIoErrlogToString(buf) {
     let i;
     let len = (i = buf.indexOf(0)) >= 0 ? i : buf.byteLength;
     return DECODER.decode(selvaIoErrlog.slice(0, len));
 }
-// add worker CTX HERE
-// then add it to every function
-// worker should allways be here
-// then add ThreadCtx to modify ctx and query ctx
 const native = {
-    threadCtx: null, // add compressors here as well!
-    workerCtxInit: () => {
-        return db.workerCtxInit();
+    getThreadId: () => {
+        return db.getThreadId();
+    },
+    createThreadCtx: (dbCtx, threadId) => {
+        db.createThreadCtx(dbCtx, threadId);
+    },
+    destroyThreadCtx: (dbCtx, threadId) => {
+        db.destroyThreadCtx(dbCtx, threadId);
     },
     externalFromInt(address) {
         return db.externalFromInt(address);

package/dist/src/server/IoWorker.js

@@ -1,5 +1,5 @@
 import { DbWorker } from './workers/DbWorker.js';
-import { DECODER, readInt32 } from '@saulx/utils';
+import { DECODER, readInt32 } from '@based/utils';
 import native from '../native.js';
 export class IoWorker extends DbWorker {
     constructor(address, db) {
@@ -8,8 +8,7 @@ export class IoWorker extends DbWorker {
         };
         super(address, db, onExit, 'io_worker.js');
     }
-    handleMsg(_buf) {
-    }
+    handleMsg(_buf) { }
     cb = (resolve) => {
         this.db.activeReaders++;
         this.resolvers.push((r) => {

package/dist/src/server/QueryWorker.js

@@ -1,5 +1,5 @@
 import { DbWorker } from './workers/DbWorker.js';
-import { readUint64 } from '@saulx/utils';
+import { readUint64 } from '@based/utils';
 export class QueryWorker extends DbWorker {
     constructor(address, db, workerIndex) {
         const onExit = (_code) => {

package/dist/src/server/blocks.js

@@ -1,7 +1,7 @@
 import native from '../native.js';
 import { join } from 'node:path';
-import { equals, readInt32 } from '@saulx/utils';
-import { VerifTree, destructureTreeKey, makeTreeKey, } from './tree.js';
+import { equals, readInt32 } from '@based/utils';
+import { VerifTree, destructureTreeKey, makeTreeKey } from './tree.js';
 const SELVA_ENOENT = -8;
 /**
  * Save a block.
@@ -64,7 +64,7 @@ export async function loadBlock(db, def, start) {
     const p = db.ioWorker.loadBlock(join(db.fileSystemPath, filename));
     block.loadPromise = p;
     await p;
-    delete block.loadPromise;
+    block.loadPromise = null;
     // Update and verify the hash
     const hash = new Uint8Array(16);
     const end = start + def.blockCapacity - 1;
@@ -106,7 +106,8 @@ export async function unloadBlock(db, def, start) {
  */
 export function foreachBlock(db, def, cb, includeEmptyBlocks = false) {
     const step = def.blockCapacity;
-    for (let start = 1; start <= def.lastId; start += step) {
+    const lastId = def.lastId || native.getTypeInfo(def.id, db.dbCtxExternal)[1];
+    for (let start = 1; start <= lastId; start += step) {
         const end = start + step - 1;
         const hash = new Uint8Array(16);
         const res = native.getNodeRangeHash(def.id, start, end, hash, db.dbCtxExternal);

package/dist/src/server/dbHash.js

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

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

@@ -1,7 +1,6 @@
-import { LangName, StrictSchema } from '@based/schema';
+import { LangName, MigrateFns, StrictSchema } from '@based/schema';
 import { StartOpts } from './start.js';
 import { VerifTree } from './tree.js';
-import { TransformFns } from './migrate/index.js';
 import exitHook from 'exit-hook';
 import { SchemaChecksum } from '../schema.js';
 import { IoWorker } from './IoWorker.js';
@@ -17,7 +16,6 @@ export declare class DbServer extends DbShared {
     #private;
     modifyDirtyRanges: Float64Array;
     dbCtxExternal: any;
-    threadCtxExternal: any;
     migrating: number;
     saveInProgress: boolean;
     fileSystemPath: string;
@@ -60,11 +58,11 @@ export declare class DbServer extends DbShared {
     destroySortIndex(type: string, field: string, lang?: LangName): any;
     getSortIndex(typeId: number, field: number, start: number, lang: number): SortIndex;
     createSortIndexBuffer(typeId: number, field: number, start: number, lang: number): SortIndex;
-    setSchema(strictSchema: StrictSchema, transformFns?: TransformFns): Promise<SchemaChecksum>;
-    modify(bufWithHash: Uint8Array): Record<number, number> | null;
+    setSchema(strictSchema: StrictSchema, transformFns?: MigrateFns): Promise<SchemaChecksum>;
+    modify(payload: Uint8Array, skipParse?: boolean): Record<number, number> | null;
     addToQueryQueue(resolve: any, buf: any): Promise<Uint8Array<ArrayBuffer>>;
     getQueryBuf(buf: Uint8Array, fromQueue?: boolean): Promise<Uint8Array>;
-    onQueryEnd(): any;
+    onQueryEnd(): void;
     stop(noSave?: boolean): Promise<void>;
     destroy(): Promise<void>;
 }

package/dist/src/server/index.js

@@ -1,13 +1,14 @@
 import native from '../native.js';
 import { rm } from 'node:fs/promises';
 import { langCodesMap } from '@based/schema';
+import { ID_FIELD_DEF } from '@based/schema/def';
 import { start } from './start.js';
 import { destructureTreeKey, makeTreeKeyFromNodeId } from './tree.js';
 import { save } from './save.js';
 import { setTimeout } from 'node:timers/promises';
 import { migrate } from './migrate/index.js';
 import { debugServer } from '../utils.js';
-import { readUint16, readUint32, readUint64 } from '@saulx/utils';
+import { readUint16, readUint32, readUint64, writeUint32 } from '@based/utils';
 import { QueryType } from '../client/query/types.js';
 import { strictSchemaToDbSchema } from './schema.js';
 import { DbShared } from '../shared/DbBase.js';
@@ -27,7 +28,6 @@ class SortIndex {
 export class DbServer extends DbShared {
     modifyDirtyRanges;
     dbCtxExternal; // pointer to zig dbCtx
-    threadCtxExternal; // pointer to zig dbCtx
     migrating = null;
     saveInProgress = false;
     fileSystemPath;
@@ -49,6 +49,10 @@ export class DbServer extends DbShared {
         this.fileSystemPath = path;
         this.sortIndexes = {};
         this.saveIntervalInSeconds = saveIntervalInSeconds;
+        if (process.stderr.isTTY) {
+            //this.on('info', (v) => console.error('Info:', v))
+            this.on('error', (v) => console.error('Error:', v));
+        }
         if (debug) {
             debugServer(this);
         }
@@ -202,17 +206,18 @@ export class DbServer extends DbShared {
         buf[4] = start >>> 8;
         let typeDef;
         let prop;
-        for (const t in this.schemaTypesParsed) {
-            typeDef = this.schemaTypesParsed[t];
-            if (typeDef.id == typeId) {
-                for (const p in typeDef.props) {
-                    const propDef = typeDef.props[p];
-                    if (propDef.prop == field && propDef.start == start) {
-                        prop = propDef;
-                        break;
-                    }
+        if (field === 255) {
+            prop = ID_FIELD_DEF;
+            typeDef = this.schemaTypesParsedById[typeId];
+        }
+        else {
+            typeDef = this.schemaTypesParsedById[typeId];
+            for (const p in typeDef.props) {
+                const propDef = typeDef.props[p];
+                if (propDef.prop == field && propDef.start == start) {
+                    prop = propDef;
+                    break;
                 }
-                break;
             }
         }
         if (!typeDef) {
@@ -234,6 +239,9 @@ export class DbServer extends DbShared {
         return sortIndex;
     }
     async setSchema(strictSchema, transformFns) {
+        if (this.stopped || !this.dbCtxExternal) {
+            throw new Error('Db is stopped');
+        }
         const schema = strictSchemaToDbSchema(strictSchema);
         if (schema.hash === this.schema?.hash) {
             // Todo something for sending back to actual client
@@ -262,89 +270,59 @@ export class DbServer extends DbShared {
         });
         return schema.hash;
     }
-    modify(bufWithHash) {
-        const schemaHash = readUint64(bufWithHash, 0);
-        if (schemaHash !== this.schema?.hash) {
-            this.emit('info', 'Schema mismatch in modify');
+    modify(payload, skipParse) {
+        const hash = readUint64(payload, 0);
+        const contentEnd = readUint32(payload, payload.byteLength - 4);
+        let result;
+        if (this.schema?.hash !== hash) {
+            this.emit('info', 'Schema mismatch in write');
             return null;
         }
-        const buf = bufWithHash.subarray(8);
-        const offsets = {};
-        const dataLen = readUint32(buf, buf.length - 4);
-        let typesSize = readUint16(buf, dataLen);
-        let i = dataLen + 2;
-        while (typesSize--) {
-            const typeId = readUint16(buf, i);
-            i += 2;
-            const startId = readUint32(buf, i);
-            const def = this.schemaTypesParsedById[typeId];
-            if (!def) {
-                console.error(`Wrong cannot get def in modify ${typeId} ${schemaHash} ${this.schema?.hash}!}`);
-                return null;
-            }
-            let offset = def.lastId - startId;
-            if (offset < 0) {
-                offset = 0;
+        if (!skipParse) {
+            result = {};
+            let i = payload.byteLength - 4;
+            while (i > contentEnd) {
+                const typeId = readUint16(payload, i - 6);
+                const count = readUint32(payload, i - 4);
+                const typeDef = this.schemaTypesParsedById[typeId];
+                if (!typeDef) {
+                    console.error('Missing typeDef, cancel write', { typeId, count });
+                    this.emit('info', 'Missing typeDef, cancel write');
+                    return null;
+                }
+                const lastId = typeDef.lastId ||
+                    native.getTypeInfo(typeDef.id, this.dbCtxExternal)[1];
+                // TODO replace this with Ctx.created
+                const offset = lastId;
+                // write the offset into payload for zig to use
+                writeUint32(payload, offset, i - 4);
+                result[typeId] = offset;
+                typeDef.lastId = lastId + count;
+                i -= 6;
             }
-            buf[i++] = offset;
-            buf[i++] = offset >>> 8;
-            buf[i++] = offset >>> 16;
-            buf[i++] = offset >>> 24;
-            const lastId = readUint32(buf, i);
-            i += 4;
-            def.lastId = lastId + offset;
-            offsets[typeId] = offset;
         }
+        const content = payload.subarray(8, contentEnd);
+        const offsets = payload.subarray(contentEnd, payload.byteLength - 4);
         if (this.activeReaders) {
-            this.modifyQueue.push(new Uint8Array(bufWithHash));
+            this.modifyQueue.push(new Uint8Array(payload));
         }
         else {
-            this.#modify(buf);
-        }
-        return offsets;
-    }
-    #modify(buf) {
-        if (this.stopped) {
-            console.error('Db is stopped - trying to modify');
-            return;
-        }
-        const end = buf.length - 4;
-        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 = readUint16(buf, i);
-            const def = this.schemaTypesParsedById[typeId];
-            const key = makeTreeKeyFromNodeId(def.id, def.blockCapacity, def.lastId);
-            this.dirtyRanges.add(key);
-            i += 10;
-        }
-        const view = new DataView(buf.buffer, buf.byteOffset);
-        while (i < end) {
-            // const key = view.getFloat64(i, true)
-            // These node ranges may not actually exist
-            // this.dirtyRanges.add(key)
-            i += 8;
-        }
-        resizeModifyDirtyRanges(this);
-        native.modify(data, types, this.dbCtxExternal, this.modifyDirtyRanges);
-        for (let key of this.modifyDirtyRanges) {
-            if (key === 0) {
-                break;
+            resizeModifyDirtyRanges(this);
+            native.modify(content, offsets, this.dbCtxExternal, this.modifyDirtyRanges);
+            for (const key of this.modifyDirtyRanges) {
+                if (key === 0)
+                    break;
+                this.dirtyRanges.add(key);
             }
-            this.dirtyRanges.add(key);
         }
+        return result;
     }
     #expire() {
         resizeModifyDirtyRanges(this);
         native.modify(emptyUint8Array, emptyUint8Array, this.dbCtxExternal, this.modifyDirtyRanges);
-        for (let key of this.modifyDirtyRanges) {
-            if (key === 0) {
+        for (const key of this.modifyDirtyRanges) {
+            if (key === 0)
                 break;
-            }
             this.dirtyRanges.add(key);
         }
     }
@@ -411,14 +389,8 @@ export class DbServer extends DbShared {
             if (this.modifyQueue.length) {
                 const modifyQueue = this.modifyQueue;
                 this.modifyQueue = [];
-                for (const bufWithHash of modifyQueue) {
-                    const schemaHash = readUint64(bufWithHash, 0);
-                    if (schemaHash !== this.schema?.hash) {
-                        this.emit('info', 'Schema mismatch in modify');
-                        return null;
-                    }
-                    const buf = bufWithHash.subarray(8);
-                    this.#modify(buf);
+                for (const payload of modifyQueue) {
+                    this.modify(payload, true);
                 }
             }
             if (this.queryQueue.size) {
@@ -454,6 +426,7 @@ export class DbServer extends DbShared {
             await Promise.all(this.workers.map((worker) => worker.terminate()));
             this.workers = [];
             native.stop(this.dbCtxExternal);
+            this.dbCtxExternal = null;
             await setTimeout(100);
         }
         catch (e) {
@@ -464,13 +437,7 @@ export class DbServer extends DbShared {
     async destroy() {
         await this.stop(true);
         if (this.fileSystemPath) {
-            await rm(this.fileSystemPath, { recursive: true }).catch((err) => {
-                // console.warn(
-                //   'Error removing dump folder',
-                //   this.fileSystemPath,
-                //   err.message,
-                // ),
-            });
+            await rm(this.fileSystemPath, { recursive: true }).catch((err) => { });
         }
     }
 }

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

@@ -1,11 +1,9 @@
 import { DbServer } from '../index.js';
 import { DbSchema } from '../../schema.js';
+import { MigrateFns } from '@based/schema';
 export type MigrateRange = {
     typeId: number;
     start: number;
     end: number;
 };
-type TransformFn = (node: Record<string, any>) => Record<string, any> | [string, Record<string, any>];
-export type TransformFns = Record<string, TransformFn>;
-export declare const migrate: (server: DbServer, fromSchema: DbSchema, toSchema: DbSchema, transform?: TransformFns) => Promise<void>;
-export {};
+export declare const migrate: (server: DbServer, fromSchema: DbSchema, toSchema: DbSchema, transform?: MigrateFns) => Promise<void>;