edinburgh 0.1.3 → 0.4.1

package/build/src/indexes.js

@@ -1,24 +1,36 @@
-import * as olmdb from "olmdb";
-import { DatabaseError } from "olmdb";
-import { Bytes } from "./bytes.js";
-import { getMockModel, modelRegistry } from "./models.js";
-import { assert, logLevel } from "./utils.js";
+import * as lowlevel from "olmdb/lowlevel";
+import { DatabaseError } from "olmdb/lowlevel";
+import DataPack from "./datapack.js";
+import { getMockModel, currentTxn } from "./models.js";
+import { scheduleInit, transact } from "./edinburgh.js";
+import { assert, logLevel, dbGet, dbPut, dbDel, hashBytes, toBuffer } from "./utils.js";
 import { deserializeType, serializeType } from "./types.js";
-/** @internal Symbol used to access the underlying model from a proxy */
-export const TARGET_SYMBOL = Symbol('target');
 const MAX_INDEX_ID_PREFIX = -1;
 const INDEX_ID_PREFIX = -2;
+const VERSION_INFO_PREFIX = -3;
+const MAX_INDEX_ID_BUFFER = new DataPack().write(MAX_INDEX_ID_PREFIX).toUint8Array();
+function bytesEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++) {
+        if (a[i] !== b[i])
+            return false;
+    }
+    return true;
+}
 /**
  * Iterator for range queries on indexes.
  * Handles common iteration logic for both primary and unique indexes.
  * Implements both Iterator and Iterable interfaces for efficiency.
  */
-class IndexRangeIterator {
-    iterator;
+export class IndexRangeIterator {
+    txn;
+    iteratorId;
     indexId;
     parentIndex;
-    constructor(iterator, indexId, parentIndex) {
-        this.iterator = iterator;
+    constructor(txn, iteratorId, indexId, parentIndex) {
+        this.txn = txn;
+        this.iteratorId = iteratorId;
         this.indexId = indexId;
         this.parentIndex = parentIndex;
     }
@@ -26,23 +38,16 @@ class IndexRangeIterator {
         return this;
     }
     next() {
-        if (!this.iterator)
+        if (this.iteratorId < 0)
             return { done: true, value: undefined };
-        const entry = this.iterator.next();
-        if (entry.done) {
-            this.iterator.close();
+        const raw = lowlevel.readIterator(this.iteratorId);
+        if (!raw) {
+            lowlevel.closeIterator(this.iteratorId);
+            this.iteratorId = -1;
             return { done: true, value: undefined };
         }
-        // Extract the key without the index ID
-        const keyBytes = new Bytes(entry.value.key);
-        const entryIndexId = keyBytes.readNumber();
-        assert(entryIndexId === this.indexId);
-        // Use polymorphism to get the model from the entry
-        const model = this.parentIndex._getModelFromEntry(keyBytes, new Bytes(entry.value.value));
-        if (!model) {
-            // This shouldn't happen, but skip if it does
-            return this.next();
-        }
+        // Dispatches to the _pairToInstance specific to the index type
+        const model = this.parentIndex._pairToInstance(this.txn, raw.key, raw.value);
         return { done: false, value: model };
     }
     count() {
@@ -68,142 +73,123 @@ class IndexRangeIterator {
 export class BaseIndex {
     _fieldNames;
     _MyModel;
+    _fieldTypes = new Map();
+    _fieldCount;
+    _resetIndexFieldDescriptors = {};
     /**
      * Create a new index.
      * @param MyModel - The model class this index belongs to.
      * @param _fieldNames - Array of field names that make up this index.
      */
-    constructor(MyModel, _fieldNames, isPrimary = false) {
+    constructor(MyModel, _fieldNames) {
         this._fieldNames = _fieldNames;
-        this._MyModel = MyModel = getMockModel(MyModel);
-        // The primary key should be [0] in _indexes
-        (MyModel._indexes ||= [])[isPrimary ? 'unshift' : 'push'](this);
+        this._MyModel = getMockModel(MyModel);
     }
-    _cachedIndexId;
-    /**
-     * Deserialize index key bytes back to field values.
-     * @param bytes - Bytes to read from.
-     * @returns Array of field values.
-     */
-    _deserializeKey(bytes) {
-        const result = [];
-        for (let i = 0; i < this._fieldNames.length; i++) {
-            const fieldName = this._fieldNames[i];
-            const fieldConfig = this._MyModel.fields[fieldName];
-            fieldConfig.type.deserialize(result, i, bytes);
+    async _delayedInit() {
+        if (this._indexId != null)
+            return; // Already initialized
+        for (const fieldName of this._fieldNames) {
+            assert(typeof fieldName === 'string', 'Field names must be strings');
+            this._fieldTypes.set(fieldName, this._MyModel.fields[fieldName].type);
         }
-        return result;
-    }
-    /**
-     * Serialize field values to bytes for index key.
-     * @param args - Field values to serialize (can be partial for range queries).
-     * @param bytes - Bytes to write to.
-     * @internal
-     */
-    _serializeArgs(args, bytes) {
-        const argsArray = Array.isArray(args) ? args : Object.values(args);
-        assert(argsArray.length <= this._fieldNames.length);
-        for (let i = 0; i < argsArray.length; i++) {
-            const fieldName = this._fieldNames[i];
-            const fieldConfig = this._MyModel.fields[fieldName];
-            fieldConfig.type.validateAndSerialize(argsArray, i, bytes);
+        this._fieldCount = this._fieldNames.length;
+        await this._retrieveIndexId();
+        // Human-readable signature for version tracking, e.g. "secondary category:string"
+        this._signature = this._getTypeName() + ' ' +
+            Array.from(this._fieldTypes.entries()).map(([n, t]) => n + ':' + t).join(' ');
+        for (const fieldName of this._fieldTypes.keys()) {
+            this._resetIndexFieldDescriptors[fieldName] = {
+                writable: true,
+                configurable: true,
+                enumerable: true
+            };
         }
     }
-    /**
-     * Create database key from field values.
-     * @param args - Field values.
-     * @returns Database key bytes.
-     */
-    _getKeyFromArgs(args) {
-        assert(args.length === this._fieldNames.length);
-        let indexId = this._getIndexId();
-        let keyBytes = new Bytes().writeNumber(indexId);
-        this._serializeArgs(args, keyBytes);
-        return keyBytes.getBuffer();
-    }
-    /**
-     * Serialize model fields to bytes for index key.
-     * @param model - Model instance.
-     * @param bytes - Bytes to write to.
-     */
-    _serializeModel(model, bytes) {
-        for (let i = 0; i < this._fieldNames.length; i++) {
-            const fieldName = this._fieldNames[i];
-            const fieldConfig = this._MyModel.fields[fieldName];
-            fieldConfig.type.validateAndSerialize(model, fieldName, bytes, model);
+    _indexId;
+    /** Human-readable signature for version tracking, e.g. "secondary category:string" */
+    _signature;
+    _argsToKeyBytes(args, allowPartial) {
+        assert(allowPartial ? args.length <= this._fieldCount : args.length === this._fieldCount);
+        const bytes = new DataPack();
+        bytes.write(this._indexId);
+        let index = 0;
+        for (const fieldType of this._fieldTypes.values()) {
+            // For partial keys, undefined values are acceptable and represent open range suffixes
+            if (index >= args.length)
+                break;
+            fieldType.serialize(args[index++], bytes);
         }
+        return bytes;
     }
-    /**
-     * Create database key from model instance.
-     * @param model - Model instance.
-     * @param includeIndexId - Whether to include index ID in key.
-     * @returns Database key bytes or undefined if skipped.
-     * @internal
-     */
-    _getKeyFromModel(model, includeIndexId) {
-        const bytes = new Bytes();
-        if (includeIndexId)
-            bytes.writeNumber(this._getIndexId());
-        this._serializeModel(model, bytes);
-        return bytes.getBuffer();
+    _hasNullIndexValues(data) {
+        for (const fieldName of this._fieldTypes.keys()) {
+            if (data[fieldName] == null)
+                return true;
+        }
+        return false;
     }
-    /**
-     * Extract field values from model for this index.
-     * @param model - Model instance.
-     * @returns Field values or undefined if should be skipped.
-     * @internal
-     */
-    _modelToArgs(model) {
-        return this._checkSkip(model) ? undefined : this._fieldNames.map((fieldName) => model[fieldName]);
+    // Returns the indexId + serialized key fields. Used in some _serializeKey implementations
+    // and for calculating _primaryKey.
+    _serializeKeyFields(data) {
+        const bytes = new DataPack();
+        bytes.write(this._indexId);
+        for (const [fieldName, fieldType] of this._fieldTypes.entries()) {
+            fieldType.serialize(data[fieldName], bytes);
+        }
+        return bytes;
     }
     /**
-     * Get or create unique index ID for this index.
-     * @returns Numeric index ID.
+     * Retrieve (or create) a stable index ID from the DB, with retry on transaction races.
+     * Sets `this._indexId` on success.
      */
-    _getIndexId() {
-        // Resolve an index to a number
-        let indexId = this._cachedIndexId;
-        if (indexId == null) {
-            const indexNameBytes = new Bytes().writeNumber(INDEX_ID_PREFIX).writeString(this._MyModel.tableName).writeString(this._getTypeName());
-            for (let name of this._fieldNames) {
-                indexNameBytes.writeString(name);
+    async _retrieveIndexId() {
+        const indexNameBytes = new DataPack().write(INDEX_ID_PREFIX).write(this._MyModel.tableName).write(this._getTypeName());
+        for (let name of this._fieldNames) {
+            indexNameBytes.write(name);
+            serializeType(this._MyModel.fields[name].type, indexNameBytes);
+        }
+        // For non-primary indexes, include primary key field info to avoid misinterpreting
+        // values when the primary key schema changes.
+        if (this._MyModel._primary !== this) {
+            indexNameBytes.write(undefined); // separator
+            for (const name of this._MyModel._primary._fieldNames) {
+                indexNameBytes.write(name);
                 serializeType(this._MyModel.fields[name].type, indexNameBytes);
             }
-            const indexNameBuf = indexNameBytes.getBuffer();
-            let result = olmdb.get(indexNameBuf);
-            if (result) {
-                indexId = this._cachedIndexId = new Bytes(result).readNumber();
+        }
+        const indexNameBuf = indexNameBytes.toUint8Array();
+        while (true) {
+            const txnId = lowlevel.startTransaction();
+            try {
+                let result = dbGet(txnId, indexNameBuf);
+                let id;
+                if (result) {
+                    id = new DataPack(result).readNumber();
+                }
+                else {
+                    result = dbGet(txnId, MAX_INDEX_ID_BUFFER);
+                    id = result ? new DataPack(result).readNumber() + 1 : 1;
+                    const idBuf = new DataPack().write(id).toUint8Array();
+                    dbPut(txnId, indexNameBuf, idBuf);
+                    dbPut(txnId, MAX_INDEX_ID_BUFFER, idBuf);
+                    if (logLevel >= 1)
+                        console.log(`[edinburgh] Create index ${this}`);
+                }
+                const commitResult = lowlevel.commitTransaction(txnId);
+                const commitSeq = typeof commitResult === 'number' ? commitResult : await commitResult;
+                if (commitSeq > 0) {
+                    this._indexId = id;
+                    return;
+                }
             }
-            else {
-                const maxIndexIdBuf = new Bytes().writeNumber(MAX_INDEX_ID_PREFIX).getBuffer();
-                result = olmdb.get(maxIndexIdBuf);
-                indexId = result ? new Bytes(result).readNumber() + 1 : 1;
-                olmdb.onCommit(() => {
-                    // Only if the transaction succeeds can we cache this id
-                    this._cachedIndexId = indexId;
-                });
-                const idBuf = new Bytes().writeNumber(indexId).getBuffer();
-                olmdb.put(indexNameBuf, idBuf);
-                olmdb.put(maxIndexIdBuf, idBuf); // This will also cause the transaction to rerun if we were raced
-                if (logLevel >= 1) {
-                    console.log(`Created index ${this._MyModel.tableName}[${this._fieldNames.join(', ')}] with id ${indexId}`);
+            catch (e) {
+                try {
+                    lowlevel.abortTransaction(txnId);
                 }
+                catch { }
+                throw e;
             }
         }
-        return indexId;
-    }
-    /**
-     * Check if indexing should be skipped for a model instance.
-     * @param model - Model instance.
-     * @returns true if indexing should be skipped.
-     */
-    _checkSkip(model) {
-        for (const fieldName of this._fieldNames) {
-            const fieldConfig = this._MyModel.fields[fieldName];
-            if (fieldConfig.type.checkSkipIndex(model, fieldName))
-                return true;
-        }
-        return false;
     }
     /**
      * Find model instances using flexible range query options.
@@ -263,51 +249,118 @@ export class BaseIndex {
      * }
      * ```
      */
-    find(opts = {}) {
-        const indexId = this._getIndexId();
-        let startKey = new Bytes().writeNumber(indexId);
-        let endKey = startKey.copy();
+    _computeKeyBounds(opts) {
+        let startKey;
+        let endKey;
         if ('is' in opts) {
-            // Exact match - set both start and end to the same value
-            this._serializeArgs(toArray(opts.is), startKey);
-            endKey = startKey.copy().increment();
+            startKey = this._argsToKeyBytes(toArray(opts.is), true);
+            endKey = startKey.clone(true).increment();
         }
         else {
-            // Range query
             if ('from' in opts) {
-                this._serializeArgs(toArray(opts.from), startKey);
+                startKey = this._argsToKeyBytes(toArray(opts.from), true);
             }
             else if ('after' in opts) {
-                this._serializeArgs(toArray(opts.after), startKey);
-                if (!startKey.increment()) {
-                    // There can be nothing 'after' - return an empty iterator
-                    return new IndexRangeIterator(undefined, indexId, this);
-                }
+                startKey = this._argsToKeyBytes(toArray(opts.after), true);
+                if (!startKey.increment())
+                    return null;
+            }
+            else {
+                startKey = this._argsToKeyBytes([], true);
             }
             if ('to' in opts) {
-                this._serializeArgs(toArray(opts.to), endKey);
-                endKey.increment();
+                endKey = this._argsToKeyBytes(toArray(opts.to), true).increment();
             }
             else if ('before' in opts) {
-                this._serializeArgs(toArray(opts.before), endKey);
+                endKey = this._argsToKeyBytes(toArray(opts.before), true);
             }
             else {
-                endKey = endKey.increment(); // Next indexId
+                endKey = this._argsToKeyBytes([], true).increment();
             }
         }
+        return [startKey, endKey];
+    }
+    find(opts = {}) {
+        const txn = currentTxn();
+        const indexId = this._indexId;
+        const bounds = this._computeKeyBounds(opts);
+        if (!bounds)
+            return new IndexRangeIterator(txn, -1, indexId, this);
+        const [startKey, endKey] = bounds;
         // For reverse scans, swap start/end keys since OLMDB expects it
         const scanStart = opts.reverse ? endKey : startKey;
         const scanEnd = opts.reverse ? startKey : endKey;
-        const iterator = olmdb.scan({
-            start: scanStart?.getBuffer(),
-            end: scanEnd?.getBuffer(),
-            reverse: opts.reverse || false,
-        });
-        return new IndexRangeIterator(iterator, indexId, this);
+        if (logLevel >= 3) {
+            console.log(`[edinburgh] Scan ${this} start=${scanStart} end=${scanEnd} reverse=${opts.reverse || false}`);
+        }
+        const startBuf = scanStart?.toUint8Array();
+        const endBuf = scanEnd?.toUint8Array();
+        const iteratorId = lowlevel.createIterator(txn.id, startBuf ? toBuffer(startBuf) : undefined, endBuf ? toBuffer(endBuf) : undefined, opts.reverse || false);
+        return new IndexRangeIterator(txn, iteratorId, indexId, this);
+    }
+    /**
+     * Process all matching rows in batched transactions.
+     *
+     * Uses the same query options as {@link find}. The batch is committed and a new
+     * transaction started once either `limitSeconds` or `limitRows` is exceeded.
+     *
+     * @param opts - Query options (same as `find()`), plus:
+     * @param opts.limitSeconds - Max seconds per transaction batch (default: 1)
+     * @param opts.limitRows - Max rows per transaction batch (default: 4096)
+     * @param callback - Called for each matching row within a transaction
+     */
+    async batchProcess(opts = {}, callback) {
+        const limitMs = (opts.limitSeconds ?? 1) * 1000;
+        const limitRows = opts.limitRows ?? 4096;
+        const reverse = opts.reverse ?? false;
+        const bounds = this._computeKeyBounds(opts);
+        if (!bounds)
+            return;
+        const startKey = bounds[0]?.toUint8Array();
+        const endKey = bounds[1]?.toUint8Array();
+        let cursor;
+        while (true) {
+            const next = await transact(async () => {
+                const txn = currentTxn();
+                const batchStart = cursor && !reverse ? cursor : startKey;
+                const batchEnd = cursor && reverse ? cursor : endKey;
+                const scanStart = reverse ? batchEnd : batchStart;
+                const scanEnd = reverse ? batchStart : batchEnd;
+                const iteratorId = lowlevel.createIterator(txn.id, scanStart ? toBuffer(scanStart) : undefined, scanEnd ? toBuffer(scanEnd) : undefined, reverse);
+                const t0 = Date.now();
+                let count = 0;
+                let lastRawKey;
+                try {
+                    while (true) {
+                        const raw = lowlevel.readIterator(iteratorId);
+                        if (!raw)
+                            return null;
+                        lastRawKey = new Uint8Array(raw.key);
+                        await callback(this._pairToInstance(txn, raw.key, raw.value));
+                        if (++count >= limitRows || Date.now() - t0 >= limitMs)
+                            break;
+                    }
+                }
+                finally {
+                    lowlevel.closeIterator(iteratorId);
+                }
+                lastRawKey = lastRawKey.slice(); // Copy, as lastRawKey points at OLMDB's internal read-only mmap
+                if (reverse)
+                    return lastRawKey;
+                const nk = new DataPack(lastRawKey);
+                return nk.increment() ? nk.toUint8Array() : null;
+            });
+            if (next === null)
+                break;
+            cursor = next;
+        }
+    }
+    toString() {
+        return `${this._indexId}:${this._MyModel.tableName}:${this._getTypeName()}[${Array.from(this._fieldTypes.keys()).join(',')}]`;
     }
 }
 function toArray(args) {
-    // Use type assertion to satisfy TypeScript while maintaining runtime correctness
+    // Convert single value or array to array format compatible with Partial<ARG_TYPES>
     return (Array.isArray(args) ? args : [args]);
 }
 /**
@@ -317,12 +370,135 @@ function toArray(args) {
  * @template F - The field names that make up this index.
  */
 export class PrimaryIndex extends BaseIndex {
+    _nonKeyFields;
+    _lazyDescriptors = {};
+    _resetDescriptors = {};
+    _freezePrimaryKeyDescriptors = {};
+    /** Current version number for this primary index's value format. */
+    _currentVersion;
+    /** Hash of the current migrate() function source, or 0 if none. */
+    _currentMigrateHash;
+    /** Cached version info for old versions (loaded on demand). */
+    _versions = new Map();
     constructor(MyModel, fieldNames) {
-        super(MyModel, fieldNames, true);
-        if (MyModel._pk && MyModel._pk !== this) {
-            throw new DatabaseError(`Model ${MyModel.tableName} already has a primary key defined`, 'INIT_ERROR');
+        super(MyModel, fieldNames);
+        if (MyModel._primary) {
+            throw new DatabaseError(`There's already a primary index defined: ${MyModel._primary}. This error may also indicate that your tsconfig.json needs to have "target": "ES2022" set.`, 'INIT_ERROR');
+        }
+        MyModel._primary = this;
+    }
+    async _delayedInit() {
+        if (this._indexId != null)
+            return; // Already initialized
+        await super._delayedInit();
+        const MyModel = this._MyModel;
+        this._nonKeyFields = Object.keys(MyModel.fields).filter(fieldName => !this._fieldNames.includes(fieldName));
+        for (const fieldName of this._nonKeyFields) {
+            this._lazyDescriptors[fieldName] = {
+                configurable: true,
+                enumerable: true,
+                get() {
+                    this.constructor._primary._lazyNow(this);
+                    return this[fieldName];
+                },
+                set(value) {
+                    this.constructor._primary._lazyNow(this);
+                    this[fieldName] = value;
+                }
+            };
+            this._resetDescriptors[fieldName] = {
+                writable: true,
+                enumerable: true
+            };
+        }
+        for (const fieldName of this._fieldNames) {
+            this._freezePrimaryKeyDescriptors[fieldName] = {
+                writable: false,
+                enumerable: true
+            };
+        }
+    }
+    /** Serialize the current version fingerprint as a DataPack object. */
+    _serializeVersionValue() {
+        const fields = [];
+        for (const fieldName of this._nonKeyFields) {
+            const tp = new DataPack();
+            serializeType(this._MyModel.fields[fieldName].type, tp);
+            fields.push([fieldName, tp.toUint8Array()]);
+        }
+        return new DataPack().write({
+            migrateHash: this._currentMigrateHash,
+            fields,
+            secondaryKeys: new Set((this._MyModel._secondaries || []).map(sec => sec._signature)),
+        }).toUint8Array();
+    }
+    /** Look up or create the current version number for this primary index. */
+    async _initVersioning() {
+        // Compute migrate hash from function source
+        const migrateFn = this._MyModel._original?.migrate ?? this._MyModel.migrate;
+        this._currentMigrateHash = migrateFn ? hashBytes(new TextEncoder().encode(migrateFn.toString().replace(/\s\s+/g, ' ').trim())) : 0;
+        const currentValueBytes = this._serializeVersionValue();
+        // Scan last 20 version info rows for this primary index
+        const scanStart = new DataPack().write(VERSION_INFO_PREFIX).write(this._indexId);
+        const scanEnd = scanStart.clone(true).increment();
+        while (true) {
+            const txnId = lowlevel.startTransaction();
+            try {
+                const iteratorId = lowlevel.createIterator(txnId, scanEnd ? toBuffer(scanEnd.toUint8Array()) : undefined, toBuffer(scanStart.toUint8Array()), true // reverse - scan newest versions first
+                );
+                let count = 0;
+                let maxVersion = 0;
+                let found = false;
+                try {
+                    while (count < 20) {
+                        const raw = lowlevel.readIterator(iteratorId);
+                        if (!raw)
+                            break;
+                        count++;
+                        const keyPack = new DataPack(new Uint8Array(raw.key));
+                        keyPack.readNumber(); // skip VERSION_INFO_PREFIX
+                        keyPack.readNumber(); // skip indexId
+                        const versionNum = keyPack.readNumber();
+                        maxVersion = Math.max(maxVersion, versionNum);
+                        const valueBytes = new Uint8Array(raw.value);
+                        if (bytesEqual(valueBytes, currentValueBytes)) {
+                            this._currentVersion = versionNum;
+                            found = true;
+                            break;
+                        }
+                    }
+                }
+                finally {
+                    lowlevel.closeIterator(iteratorId);
+                }
+                if (found) {
+                    lowlevel.abortTransaction(txnId);
+                    return;
+                }
+                // No match found - create new version
+                this._currentVersion = maxVersion + 1;
+                const versionKey = new DataPack()
+                    .write(VERSION_INFO_PREFIX)
+                    .write(this._indexId)
+                    .write(this._currentVersion)
+                    .toUint8Array();
+                dbPut(txnId, versionKey, currentValueBytes);
+                if (logLevel >= 1)
+                    console.log(`[edinburgh] Create version ${this._currentVersion} for ${this}`);
+                const commitResult = lowlevel.commitTransaction(txnId);
+                const commitSeq = typeof commitResult === 'number' ? commitResult : await commitResult;
+                if (commitSeq > 0)
+                    return;
+                // Race - retry
+            }
+            catch (e) {
+                try {
+                    lowlevel.abortTransaction(txnId);
+                }
+                catch { }
+                throw e;
+            }
         }
-        MyModel._pk = this;
     }
     /**
      * Get a model instance by primary key values.
@@ -335,86 +511,198 @@ export class PrimaryIndex extends BaseIndex {
      * ```
      */
     get(...args) {
-        let keyBuffer = this._getKeyFromArgs(args);
-        if (logLevel >= 3) {
-            console.log(`Getting primary ${this._MyModel.tableName}[${this._fieldNames.join(', ')}] (id=${this._getIndexId()}) with key`, args, keyBuffer);
+        return this._get(currentTxn(), args, true);
+    }
+    /**
+     * Does the same as as `get()`, but will delay loading the instance from disk until the first
+     * property access. In case it turns out the instance doesn't exist, an error will be thrown
+     * at that time.
+     * @param args Primary key field values. (Or a single Uint8Array containing the key.)
+     * @returns The (lazily loaded) model instance.
+     */
+    getLazy(...args) {
+        return this._get(currentTxn(), args, false);
+    }
+    _get(txn, args, loadNow) {
+        let key, keyParts;
+        if (args instanceof Uint8Array) {
+            key = args;
         }
-        let valueBuffer = olmdb.get(keyBuffer);
-        if (!valueBuffer)
-            return;
-        // This is a primary index. So we can now deserialize all primary and non-primary fields into instance values.
-        const model = new this._MyModel();
-        // We'll want to set all loaded values on the unproxied target object.
-        const unproxied = model[TARGET_SYMBOL];
-        unproxied._state = 2; // Loaded from disk, unmodified
-        const valueBytes = new Bytes(valueBuffer);
-        let primaryKeyIndex = 0;
-        for (const [fieldName, fieldConfig] of Object.entries(this._MyModel.fields)) {
-            if (this._fieldNames.includes(fieldName)) { // Value is part of primary key
-                unproxied[fieldName] = args[primaryKeyIndex];
-                primaryKeyIndex++;
+        else {
+            key = this._argsToKeyBytes(args, false).toUint8Array();
+            keyParts = args;
+        }
+        const keyHash = hashBytes(key);
+        const cached = txn.instancesByPk.get(keyHash);
+        if (cached) {
+            if (loadNow && loadNow !== true) {
+                // The object already exists, but it may still be lazy-loaded
+                Object.defineProperties(cached, this._resetDescriptors);
+                this._setNonKeyValues(cached, loadNow);
+            }
+            return cached;
+        }
+        let valueBuffer;
+        if (loadNow) {
+            if (loadNow === true) {
+                valueBuffer = dbGet(txn.id, key);
+                if (logLevel >= 3) {
+                    console.log(`[edinburgh] Get ${this} key=${new DataPack(key)} result=${valueBuffer && new DataPack(valueBuffer)}`);
+                }
+                if (!valueBuffer)
+                    return;
             }
             else {
-                // We're passing in the proxied model
-                fieldConfig.type.deserialize(unproxied, fieldName, valueBytes, model);
+                valueBuffer = loadNow; // Uint8Array
+            }
+        }
+        // This is a primary index. So we can now deserialize all primary and non-primary fields into instance values.
+        const model = new this._MyModel(undefined, txn);
+        // Set to the original value for all fields that are loaded by _setLoadedField
+        model._oldValues = {};
+        // Set the primary key fields on the model
+        if (keyParts) {
+            let index = 0;
+            for (const fieldName of this._fieldTypes.keys()) {
+                model._setLoadedField(fieldName, keyParts[index++]);
+            }
+        }
+        else {
+            const bytes = new DataPack(key);
+            assert(bytes.readNumber() === this._MyModel._primary._indexId); // Skip index id
+            for (const [fieldName, fieldType] of this._fieldTypes.entries()) {
+                model._setLoadedField(fieldName, fieldType.deserialize(bytes));
             }
         }
+        // Store the canonical primary key on the model, set the hash, and freeze the primary key fields.
+        model._setPrimaryKey(key, keyHash);
+        if (valueBuffer) {
+            // Non-lazy load. Set other fields
+            this._setNonKeyValues(model, valueBuffer);
+        }
+        else {
+            // Lazy - set getters for other fields
+            Object.defineProperties(model, this._lazyDescriptors);
+            // When creating a lazy instance, we don't need to add it to txn.instances yet, as only the
+            // primary key fields are loaded, and they cannot be modified (so we don't need to check).
+            // When any other field is set, that will trigger a lazy-load, adding the instance to
+            // txn.instances.
+        }
+        txn.instancesByPk.set(keyHash, model);
         return model;
     }
-    /**
-     * Extract model from iterator entry for primary index.
-     * @param keyBytes - Key bytes with index ID already read.
-     * @param valueBytes - Value bytes from the entry.
-     * @returns Model instance or undefined.
-     * @internal
-     */
-    _getModelFromEntry(keyBytes, valueBytes) {
-        const model = new this._MyModel();
-        // We'll want to set all loaded values on the unproxied target object.
-        const unproxied = model[TARGET_SYMBOL];
-        unproxied._state = 2; // Loaded from disk, unmodified
-        for (let i = 0; i < this._fieldNames.length; i++) {
-            const fieldName = this._fieldNames[i];
-            const fieldConfig = this._MyModel.fields[fieldName];
-            fieldConfig.type.deserialize(unproxied, fieldName, keyBytes);
-        }
-        for (const [fieldName, fieldConfig] of Object.entries(this._MyModel.fields)) {
-            if (this._fieldNames.includes(fieldName))
-                continue; // Value is part of primary key
-            // We're passing in the proxied model
-            fieldConfig.type.deserialize(unproxied, fieldName, valueBytes, model);
+    _serializeKey(primaryKey, _data) {
+        return primaryKey;
+    }
+    _lazyNow(model) {
+        let valueBuffer = dbGet(model._txn.id, model._primaryKey);
+        if (logLevel >= 3) {
+            console.log(`[edinburgh] Lazy retrieve ${this} key=${new DataPack(model._primaryKey)} result=${valueBuffer && new DataPack(valueBuffer)}`);
         }
-        return model;
+        if (!valueBuffer)
+            throw new DatabaseError(`Lazy-loaded ${model.constructor.name}#${model._primaryKey} does not exist`, 'LAZY_FAIL');
+        Object.defineProperties(model, this._resetDescriptors);
+        this._setNonKeyValues(model, valueBuffer);
     }
-    /**
-     * Save primary index entry.
-     * @param model - Model instance.
-     * @param originalKey - Original key if updating.
-     */
-    _save(model, originalKey) {
-        // Note: this can (and usually will) be called on the non-proxied model instance.
-        assert(this._MyModel.prototype === model.constructor.prototype);
-        let newKey = this._getKeyFromModel(model, true);
-        if (originalKey && Buffer.compare(newKey, originalKey))
-            throw new DatabaseError(`Cannot change primary key for ${this._MyModel.tableName}[${this._fieldNames.join(', ')}]: ${originalKey} -> ${newKey}`, 'PRIMARY_CHANGE');
-        // Serialize all non-primary key fields
-        let valBytes = new Bytes();
-        for (const [fieldName, fieldConfig] of Object.entries(model._fields)) {
-            if (!this._fieldNames.includes(fieldName)) {
-                fieldConfig.type.validateAndSerialize(model, fieldName, valBytes, model);
+    _setNonKeyValues(model, valueArray) {
+        const fieldConfigs = this._MyModel.fields;
+        const valuePack = new DataPack(valueArray);
+        const version = valuePack.readNumber();
+        if (version === this._currentVersion) {
+            for (const fieldName of this._nonKeyFields) {
+                model._setLoadedField(fieldName, fieldConfigs[fieldName].type.deserialize(valuePack));
             }
         }
-        olmdb.put(newKey, valBytes.getBuffer());
-        if (logLevel >= 2) {
-            const keyBytes = new Bytes(newKey);
-            let indexId = keyBytes.readNumber();
-            console.log(`Saved primary ${this._MyModel.tableName}[${this._fieldNames.join(', ')}] (id=${indexId}) with key`, this._deserializeKey(keyBytes), keyBytes.getBuffer());
+        else {
+            this._migrateFromVersion(model, version, valuePack);
+        }
+    }
+    /** Load a version's info from DB, caching the result. */
+    _loadVersionInfo(txnId, version) {
+        let info = this._versions.get(version);
+        if (info)
+            return info;
+        const key = new DataPack()
+            .write(VERSION_INFO_PREFIX)
+            .write(this._indexId)
+            .write(version)
+            .toUint8Array();
+        const raw = dbGet(txnId, key);
+        if (!raw)
+            throw new DatabaseError(`Version ${version} info not found for index ${this}`, 'CONSISTENCY_ERROR');
+        const obj = new DataPack(raw).read();
+        if (!obj || typeof obj.migrateHash !== 'number' || !Array.isArray(obj.fields) || !(obj.secondaryKeys instanceof Set))
+            throw new DatabaseError(`Version ${version} info is corrupted for index ${this}`, 'CONSISTENCY_ERROR');
+        const nonKeyFields = new Map();
+        for (const [name, typeBytes] of obj.fields) {
+            nonKeyFields.set(name, deserializeType(new DataPack(typeBytes), 0));
         }
-        return newKey;
+        info = { migrateHash: obj.migrateHash, nonKeyFields, secondaryKeys: obj.secondaryKeys };
+        this._versions.set(version, info);
+        return info;
+    }
+    /** Deserialize and migrate a row from an old version. */
+    _migrateFromVersion(model, version, valuePack) {
+        const versionInfo = this._loadVersionInfo(model._txn.id, version);
+        // Deserialize using old field types into a plain record
+        const record = {};
+        for (const [name] of this._fieldTypes.entries())
+            record[name] = model[name]; // pk fields
+        for (const [name, type] of versionInfo.nonKeyFields.entries()) {
+            record[name] = type.deserialize(valuePack);
+        }
+        // Run migrate() if it exists
+        const migrateFn = this._MyModel.migrate;
+        if (migrateFn)
+            migrateFn(record);
+        // Set non-key fields on model from the (possibly migrated) record
+        for (const fieldName of this._nonKeyFields) {
+            if (fieldName in record) {
+                model._setLoadedField(fieldName, record[fieldName]);
+            }
+            else if (fieldName in model) {
+                // Instantiate the default value
+                model._setLoadedField(fieldName, model[fieldName]);
+            }
+            else {
+                throw new DatabaseError(`Field ${fieldName} is missing in migrated data for ${model}`, 'MIGRATION_ERROR');
+            }
+        }
+    }
+    _keyToArray(key) {
+        const bytes = new DataPack(key);
+        assert(bytes.readNumber() === this._indexId);
+        const result = [];
+        for (const fieldType of this._fieldTypes.values()) {
+            result.push(fieldType.deserialize(bytes));
+        }
+        return result;
+    }
+    _pairToInstance(txn, keyBuffer, valueBuffer) {
+        return this._get(txn, new Uint8Array(keyBuffer), new Uint8Array(valueBuffer));
     }
     _getTypeName() {
         return 'primary';
     }
+    _write(txn, primaryKey, data) {
+        let valueBytes = new DataPack();
+        valueBytes.write(this._currentVersion);
+        const fieldConfigs = this._MyModel.fields;
+        for (const fieldName of this._nonKeyFields) {
+            const fieldConfig = fieldConfigs[fieldName];
+            fieldConfig.type.serialize(data[fieldName], valueBytes);
+        }
+        if (logLevel >= 2) {
+            console.log(`[edinburgh] Write ${this} key=${new DataPack(primaryKey)} value=${valueBytes}`);
+        }
+        dbPut(txn.id, primaryKey, valueBytes.toUint8Array());
+    }
+    _delete(txn, primaryKey, _data) {
+        if (logLevel >= 2) {
+            console.log(`[edinburgh] Delete ${this} key=${new DataPack(primaryKey)}`);
+        }
+        dbDel(txn.id, primaryKey);
+    }
 }
 /**
  * Unique index that stores references to the primary key.
@@ -423,6 +711,11 @@ export class PrimaryIndex extends BaseIndex {
  * @template F - The field names that make up this index.
  */
 export class UniqueIndex extends BaseIndex {
+    constructor(MyModel, fieldNames) {
+        super(MyModel, fieldNames);
+        (this._MyModel._secondaries ||= []).push(this);
+        scheduleInit();
+    }
     /**
      * Get a model instance by unique index key values.
      * @param args - The unique index key values.
@@ -434,70 +727,65 @@ export class UniqueIndex extends BaseIndex {
      * ```
      */
     get(...args) {
-        let keyBuffer = this._getKeyFromArgs(args);
+        const txn = currentTxn();
+        let keyBuffer = this._argsToKeyBytes(args, false).toUint8Array();
+        let valueBuffer = dbGet(txn.id, keyBuffer);
         if (logLevel >= 3) {
-            console.log(`Getting unique ${this._MyModel.tableName}[${this._fieldNames.join(', ')}] (id=${this._getIndexId()}) with key`, args, keyBuffer);
+            console.log(`[edinburgh] Get ${this} key=${new DataPack(keyBuffer)} result=${valueBuffer}`);
         }
-        let valueBuffer = olmdb.get(keyBuffer);
         if (!valueBuffer)
             return;
-        const pk = this._MyModel._pk;
-        const valueArgs = pk._deserializeKey(new Bytes(valueBuffer));
-        const result = pk.get(...valueArgs);
+        const pk = this._MyModel._primary;
+        const result = pk._get(txn, valueBuffer, true);
         if (!result)
-            throw new DatabaseError(`Unique index ${this._MyModel.tableName}[${this._fieldNames.join(', ')}] points at non-existing primary for key: ${args.join(', ')}`, 'CONSISTENCY_ERROR');
+            throw new DatabaseError(`Unique index ${this} points at non-existing primary for key: ${args.join(', ')}`, 'CONSISTENCY_ERROR');
         return result;
     }
-    /**
-     * Extract model from iterator entry for unique index.
-     * @param keyBytes - Key bytes with index ID already read.
-     * @param valueBytes - Value bytes from the entry.
-     * @returns Model instance or undefined.
-     * @internal
-     */
-    _getModelFromEntry(keyBytes, valueBytes) {
-        // For unique indexes, the value contains the primary key
-        const pk = this._MyModel._pk;
-        const primaryKeyArgs = pk._deserializeKey(valueBytes);
-        return pk.get(...primaryKeyArgs);
+    _serializeKey(primaryKey, data) {
+        return this._serializeKeyFields(data).toUint8Array();
     }
-    /**
-     * Save unique index entry.
-     * @param model - Model instance.
-     * @param originalKey - Original key if updating.
-     */
-    _save(model, originalKey) {
-        // Note: this can (and usually will) be called on the non-proxied model instance.
-        assert(this._MyModel.prototype === model.constructor.prototype);
-        let newKey = this._checkSkip(model) ? undefined : this._getKeyFromModel(model, true);
-        if (originalKey) {
-            if (newKey && Buffer.compare(newKey, originalKey) === 0) {
-                // No change in index key, nothing to do
-                return newKey;
+    _delete(txn, primaryKey, data) {
+        if (!this._hasNullIndexValues(data)) {
+            const key = this._serializeKey(primaryKey, data);
+            if (logLevel >= 2) {
+                console.log(`[edinburgh] Delete ${this} key=${key}`);
             }
-            olmdb.del(originalKey);
+            dbDel(txn.id, key);
         }
-        if (!newKey) {
-            // No new key, nothing to do
-            return;
-        }
-        // Check that this is not a duplicate key
-        if (olmdb.get(newKey)) {
-            throw new DatabaseError(`Unique constraint violation for ${model.constructor.tableName}[${this._fieldNames.join('+')}]`, 'UNIQUE_CONSTRAINT');
+    }
+    _write(txn, primaryKey, data) {
+        if (!this._hasNullIndexValues(data)) {
+            const key = this._serializeKey(primaryKey, data);
+            if (logLevel >= 2) {
+                console.log(`[edinburgh] Write ${this} key=${key} value=${new DataPack(primaryKey)}`);
+            }
+            if (dbGet(txn.id, key)) {
+                throw new DatabaseError(`Unique constraint violation for ${this} key ${key}`, 'UNIQUE_CONSTRAINT');
+            }
+            dbPut(txn.id, key, primaryKey);
         }
-        let linkKey = model.constructor._pk._getKeyFromModel(model, false);
-        olmdb.put(newKey, linkKey);
-        if (logLevel >= 2) {
-            console.log(`Saved unique index ${this._MyModel.tableName}[${this._fieldNames.join(', ')}] with key ${newKey}`);
+    }
+    _pairToInstance(txn, keyBuffer, valueBuffer) {
+        // For unique indexes, the value contains the primary key
+        const keyPack = new DataPack(new Uint8Array(keyBuffer));
+        keyPack.readNumber(); // discard index id
+        const pk = this._MyModel._primary;
+        const model = pk._get(txn, new Uint8Array(valueBuffer), false);
+        // _get will have created lazy-load getters for our indexed fields. Let's turn them back into
+        // regular properties:
+        Object.defineProperties(model, this._resetIndexFieldDescriptors);
+        // Set the values for our indexed fields
+        for (const [name, fieldType] of this._fieldTypes.entries()) {
+            model._setLoadedField(name, fieldType.deserialize(keyPack));
         }
-        return newKey;
+        return model;
     }
     _getTypeName() {
         return 'unique';
     }
 }
 // OLMDB does not support storing empty values, so we use a single byte value for secondary indexes.
-const SECONDARY_VALUE = new Uint8Array([1]); // Single byte value for secondary indexes
+const SECONDARY_VALUE = new DataPack().write(undefined).toUint8Array(); // Single byte value for secondary indexes
 /**
  * Secondary index for non-unique lookups.
  *
@@ -505,69 +793,54 @@ const SECONDARY_VALUE = new Uint8Array([1]); // Single byte value for secondary
  * @template F - The field names that make up this index.
  */
 export class SecondaryIndex extends BaseIndex {
-    /**
-     * Save secondary index entry.
-     * @param model - Model instance.
-     * @param originalKey - Original key if updating.
-     */
-    _save(model, originalKey) {
-        // Note: this can (and usually will) be called on the non-proxied model instance.
-        assert(this._MyModel.prototype === model.constructor.prototype);
-        let newKey = this._getKeyFromModel(model, true);
-        if (originalKey) {
-            if (newKey && Buffer.compare(newKey, originalKey) === 0) {
-                // No change in index key, nothing to do
-                return;
-            }
-            olmdb.del(originalKey);
+    constructor(MyModel, fieldNames) {
+        super(MyModel, fieldNames);
+        (this._MyModel._secondaries ||= []).push(this);
+        scheduleInit();
+    }
+    _pairToInstance(txn, keyBuffer, _valueBuffer) {
+        // For secondary indexes, the primary key is stored after the index fields in the key
+        const keyPack = new DataPack(new Uint8Array(keyBuffer));
+        keyPack.readNumber(); // discard index id
+        // Read the index fields, saving them for later
+        const indexFields = new Map();
+        for (const [name, type] of this._fieldTypes.entries()) {
+            indexFields.set(name, type.deserialize(keyPack));
         }
-        if (!newKey) {
-            // No new key, nothing to do (index should be skipped)
-            return;
+        const primaryKey = keyPack.readUint8Array();
+        const model = this._MyModel._primary._get(txn, primaryKey, false);
+        // _get will have created lazy-load getters for our indexed fields. Let's turn them back into
+        // regular properties:
+        Object.defineProperties(model, this._resetIndexFieldDescriptors);
+        // Set the values for our indexed fields
+        for (const [name, value] of indexFields) {
+            model._setLoadedField(name, value);
         }
-        // For secondary indexes, we store a single byte value
-        olmdb.put(newKey, SECONDARY_VALUE);
+        return model;
+    }
+    _serializeKey(primaryKey, model) {
+        // index id + index fields + primary key
+        const bytes = super._serializeKeyFields(model);
+        bytes.write(primaryKey);
+        return bytes.toUint8Array();
+    }
+    _write(txn, primaryKey, model) {
+        if (this._hasNullIndexValues(model))
+            return;
+        const key = this._serializeKey(primaryKey, model);
         if (logLevel >= 2) {
-            console.log(`Saved secondary index ${this._MyModel.tableName}[${this._fieldNames.join(', ')}] with key ${newKey}`);
+            console.log(`[edinburgh] Write ${this} key=${key}`);
         }
-        return newKey;
-    }
-    /**
-     * Extract model from iterator entry for secondary index.
-     * @param keyBytes - Key bytes with index ID already read.
-     * @param valueBytes - Value bytes from the entry.
-     * @returns Model instance or undefined.
-     * @internal
-     */
-    _getModelFromEntry(keyBytes, valueBytes) {
-        // For secondary indexes, the primary key is stored after the index fields in the key
-        // First skip past the index fields
-        const temp = [];
-        for (let i = 0; i < this._fieldNames.length; i++) {
-            const fieldName = this._fieldNames[i];
-            const fieldConfig = this._MyModel.fields[fieldName];
-            fieldConfig.type.deserialize(temp, 0, keyBytes);
-        }
-        // Now deserialize the primary key from the remaining bytes
-        const pk = this._MyModel._pk;
-        const primaryKeyArgs = pk._deserializeKey(keyBytes);
-        return pk.get(...primaryKeyArgs);
+        dbPut(txn.id, key, SECONDARY_VALUE);
     }
-    /**
-     * Create secondary index key that includes both index fields and primary key.
-     * @param model - Model instance.
-     * @returns Database key bytes or undefined if skipped.
-     */
-    _getKeyFromModel(model, includeIndexId) {
-        const bytes = new Bytes();
-        if (includeIndexId)
-            bytes.writeNumber(this._getIndexId());
-        // Write the index fields
-        this._serializeModel(model, bytes);
-        // Write the primary key fields
-        const pk = this._MyModel._pk;
-        pk._serializeModel(model, bytes);
-        return bytes.getBuffer();
+    _delete(txn, primaryKey, model) {
+        if (this._hasNullIndexValues(model))
+            return;
+        const key = this._serializeKey(primaryKey, model);
+        if (logLevel >= 2) {
+            console.log(`[edinburgh] Delete ${this} key=${key}`);
+        }
+        dbDel(txn.id, key);
     }
     _getTypeName() {
         return 'secondary';
@@ -589,44 +862,81 @@ export function index(MyModel, fields) {
  * This is primarily useful for development and debugging purposes.
  */
 export function dump() {
+    const txn = currentTxn();
     let indexesById = new Map();
-    console.log("--- Database dump ---");
-    for (const { key, value } of olmdb.scan()) {
-        const kb = new Bytes(key);
-        const vb = new Bytes(value);
-        const indexId = kb.readNumber();
-        if (indexId === MAX_INDEX_ID_PREFIX) {
-            console.log("* Max index id", vb.readNumber());
-        }
-        else if (indexId === INDEX_ID_PREFIX) {
-            const name = kb.readString();
-            const type = kb.readString();
-            const fields = {};
-            while (kb.readAvailable()) {
+    let versions = new Map();
+    console.log("--- edinburgh database dump ---");
+    const iteratorId = lowlevel.createIterator(txn.id, undefined, undefined, false);
+    try {
+        while (true) {
+            const raw = lowlevel.readIterator(iteratorId);
+            if (!raw)
+                break;
+            const kb = new DataPack(new Uint8Array(raw.key));
+            const vb = new DataPack(new Uint8Array(raw.value));
+            const indexId = kb.readNumber();
+            if (indexId === MAX_INDEX_ID_PREFIX) {
+                console.log("* Max index id", vb.readNumber());
+            }
+            else if (indexId === VERSION_INFO_PREFIX) {
+                const idxId = kb.readNumber();
+                const version = kb.readNumber();
+                const obj = vb.read();
+                const nonKeyFields = new Map();
+                for (const [name, typeBytes] of obj.fields) {
+                    nonKeyFields.set(name, deserializeType(new DataPack(typeBytes), 0));
+                }
+                if (!versions.has(idxId))
+                    versions.set(idxId, new Map());
+                versions.get(idxId).set(version, nonKeyFields);
+                console.log(`* Version ${version} for index ${idxId}: fields=[${[...nonKeyFields.keys()].join(',')}]`);
+            }
+            else if (indexId === INDEX_ID_PREFIX) {
                 const name = kb.readString();
-                fields[name] = deserializeType(kb, 0);
+                const type = kb.readString();
+                const fields = {};
+                while (kb.readAvailable()) {
+                    const name = kb.read();
+                    if (name === undefined)
+                        break; // what follows are primary key fields (when this is a secondary index)
+                    fields[name] = deserializeType(kb, 0);
+                }
+                const indexId = vb.readNumber();
+                console.log(`* Index definition ${indexId}:${name}:${type}[${Object.keys(fields).join(',')}]`);
+                indexesById.set(indexId, { name, type, fields });
+            }
+            else if (indexId > 0 && indexesById.has(indexId)) {
+                const index = indexesById.get(indexId);
+                let name, type, rowKey, rowValue;
+                if (index) {
+                    name = index.name;
+                    type = index.type;
+                    const fields = index.fields;
+                    rowKey = {};
+                    for (const [fieldName, fieldType] of Object.entries(fields)) {
+                        rowKey[fieldName] = fieldType.deserialize(kb);
+                    }
+                    if (type === 'primary') {
+                        const version = vb.readNumber();
+                        const vFields = versions.get(indexId)?.get(version);
+                        if (vFields) {
+                            rowValue = {};
+                            for (const [fieldName, fieldType] of vFields) {
+                                rowValue[fieldName] = fieldType.deserialize(vb);
+                            }
+                        }
+                    }
+                }
+                console.log(`* Row for ${indexId}:${name}:${type}`, rowKey ?? kb, rowValue ?? vb);
             }
-            const fieldDescription = Object.entries(fields).map(([name, type]) => `${name}:${type}`);
-            const indexId = vb.readNumber();
-            console.log(`* Definition for ${type} ${indexId} for ${name}[${fieldDescription.join(',')}]`);
-            indexesById.set(indexId, { name, type, fields });
-        }
-        else if (indexId > 0 && indexesById.has(indexId)) {
-            const index = indexesById.get(indexId);
-            const { name, type, fields } = index;
-            const rowKey = {};
-            for (const [fieldName, fieldType] of Object.entries(fields)) {
-                fieldType.deserialize(rowKey, fieldName, kb);
+            else {
+                console.log(`* Unhandled '${indexId}' key=${kb} value=${vb}`);
             }
-            const Model = modelRegistry[name];
-            // TODO: once we're storing schemas (serializeType) in the db, we can deserialize here
-            let displayValue = (type === 'secondary') ? Model._pk._deserializeKey(kb) : vb;
-            console.log(`* Row for ${type} ${indexId} with key ${JSON.stringify(rowKey)}`, displayValue);
-        }
-        else {
-            console.log(`* Unhandled ${indexId} index key=${kb} value=${vb}`);
         }
     }
-    console.log("--- End of database dump ---");
+    finally {
+        lowlevel.closeIterator(iteratorId);
+    }
+    console.log("--- end ---");
 }
 //# sourceMappingURL=indexes.js.map