edinburgh 0.4.6 → 0.6.0

package/build/src/indexes.js

@@ -1,8 +1,7 @@
 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 { currentTxn, transact } from "./edinburgh.js";
 import { assert, logLevel, dbGet, dbPut, dbDel, hashBytes, hashFunction, bytesEqual, toBuffer } from "./utils.js";
 import { deserializeType, serializeType } from "./types.js";
 const MAX_INDEX_ID_PREFIX = -1;
@@ -17,15 +16,14 @@ const MAX_INDEX_ID_BUFFER = new DataPack().write(MAX_INDEX_ID_PREFIX).toUint8Arr
 export class IndexRangeIterator extends Iterator {
     txn;
     iteratorId;
-    indexId;
     parentIndex;
-    constructor(txn, iteratorId, indexId, parentIndex) {
+    constructor(txn, iteratorId, parentIndex) {
         super();
         this.txn = txn;
         this.iteratorId = iteratorId;
-        this.indexId = indexId;
         this.parentIndex = parentIndex;
     }
+    [Symbol.iterator]() { return this; }
     next() {
         if (this.iteratorId < 0)
             return { done: true, value: undefined };
@@ -35,7 +33,6 @@ export class IndexRangeIterator extends Iterator {
             this.iteratorId = -1;
             return { done: true, value: undefined };
         }
-        // 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 };
     }
@@ -47,7 +44,7 @@ export class IndexRangeIterator extends Iterator {
     }
     fetch() {
         for (const model of this) {
-            return model; // Return the first model found
+            return model;
         }
     }
 }
@@ -55,61 +52,50 @@ export class IndexRangeIterator extends Iterator {
  * Base class for database indexes for efficient lookups on model fields.
  *
  * Indexes enable fast queries on specific field combinations and enforce uniqueness constraints.
- *
- * @template M - The model class this index belongs to.
- * @template F - The field names that make up this index.
  */
 export class BaseIndex {
-    _fieldNames;
-    _MyModel;
-    _fieldTypes = new Map();
-    _fieldCount;
-    _resetIndexFieldDescriptors = {};
+    tableName;
+    _indexFields = new Map();
     _computeFn;
-    /**
-     * 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) {
-        this._fieldNames = _fieldNames;
-        this._MyModel = getMockModel(MyModel);
+    _indexId;
+    _signature;
+    constructor(tableName, fieldNames) {
+        this.tableName = tableName;
+        this._indexFields = new Map(fieldNames.map(fieldName => [fieldName, undefined]));
     }
-    async _delayedInit() {
-        if (this._indexId != null)
-            return; // Already initialized
+    async _initializeIndex(fields, reset = false, primaryFieldTypes) {
+        const fieldNames = [...this._indexFields.keys()];
+        if (reset) {
+            this._indexId = undefined;
+            this._signature = undefined;
+        }
+        else if (this._indexId != null) {
+            return;
+        }
         if (this._computeFn) {
-            this._fieldCount = 1;
+            this._indexFields = new Map();
         }
         else {
-            for (const fieldName of this._fieldNames) {
+            this._indexFields = new Map();
+            for (const fieldName of fieldNames) {
                 assert(typeof fieldName === 'string', 'Field names must be strings');
-                this._fieldTypes.set(fieldName, this._MyModel.fields[fieldName].type);
+                const fieldType = fields.get(fieldName);
+                assert(fieldType, `Unknown field '${fieldName}' in ${this}`);
+                this._indexFields.set(fieldName, fieldType);
             }
-            this._fieldCount = this._fieldNames.length;
         }
-        await this._retrieveIndexId();
-        // Human-readable signature for version tracking, e.g. "secondary category:string"
+        await this._retrieveIndexId(fields, primaryFieldTypes);
         if (this._computeFn) {
             this._signature = this._getTypeName() + ' ' + hashFunction(this._computeFn);
         }
         else {
             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
-            };
+                Array.from(this._indexFields.entries()).map(([name, fieldType]) => name + ':' + fieldType).join(' ');
         }
     }
-    _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 expectedCount = this._computeFn ? 1 : this._indexFields.size;
+        assert(allowPartial ? args.length <= expectedCount : args.length === expectedCount);
         const bytes = new DataPack();
         bytes.write(this._indexId);
         if (this._computeFn) {
@@ -118,8 +104,7 @@ export class BaseIndex {
         }
         else {
             let index = 0;
-            for (const fieldType of this._fieldTypes.values()) {
-                // For partial keys, undefined values are acceptable and represent open range suffixes
+            for (const fieldType of this._indexFields.values()) {
                 if (index >= args.length)
                     break;
                 fieldType.serialize(args[index++], bytes);
@@ -127,52 +112,22 @@ export class BaseIndex {
         }
         return bytes;
     }
-    _hasNullIndexValues(data) {
-        assert(!this._computeFn);
-        for (const fieldName of this._fieldTypes.keys()) {
-            if (data[fieldName] == null)
-                return true;
-        }
-        return false;
-    }
-    // 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);
-        if (this._computeFn) {
-            for (const v of this._computeFn(data))
-                bytes.write(v);
-        }
-        else {
-            for (const [fieldName, fieldType] of this._fieldTypes.entries()) {
-                fieldType.serialize(data[fieldName], bytes);
-            }
-        }
-        return bytes;
-    }
-    /**
-     * Retrieve (or create) a stable index ID from the DB, with retry on transaction races.
-     * Sets `this._indexId` on success.
-     */
-    async _retrieveIndexId() {
-        const indexNameBytes = new DataPack().write(INDEX_ID_PREFIX).write(this._MyModel.tableName).write(this._getTypeName());
+    async _retrieveIndexId(fields, primaryFieldTypes) {
+        const indexNameBytes = new DataPack().write(INDEX_ID_PREFIX).write(this.tableName).write(this._getTypeName());
         if (this._computeFn) {
             indexNameBytes.write(hashFunction(this._computeFn));
         }
         else {
-            for (let name of this._fieldNames) {
+            for (const name of this._indexFields.keys()) {
                 indexNameBytes.write(name);
-                serializeType(this._MyModel.fields[name].type, indexNameBytes);
+                serializeType(fields.get(name), 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) {
+        if (primaryFieldTypes) {
+            indexNameBytes.write(undefined);
+            for (const [name, fieldType] of primaryFieldTypes.entries()) {
                 indexNameBytes.write(name);
-                serializeType(this._MyModel.fields[name].type, indexNameBytes);
+                serializeType(fieldType, indexNameBytes);
             }
         }
         const indexNameBuf = indexNameBytes.toUint8Array();
@@ -209,64 +164,6 @@ export class BaseIndex {
             }
         }
     }
-    /**
-     * Find model instances using flexible range query options.
-     *
-     * Supports exact matches, inclusive/exclusive range queries, and reverse iteration.
-     * For single-field indexes, you can pass values directly or in arrays.
-     * For multi-field indexes, pass arrays or partial arrays for prefix matching.
-     *
-     * @param opts - Query options object
-     * @param opts.is - Exact match (sets both `from` and `to` to same value)
-     * @param opts.from - Range start (inclusive)
-     * @param opts.after - Range start (exclusive)
-     * @param opts.to - Range end (inclusive)
-     * @param opts.before - Range end (exclusive)
-     * @param opts.reverse - Whether to iterate in reverse order
-     * @returns An iterable of model instances matching the query
-     *
-     * @example
-     * ```typescript
-     * // Exact match
-     * for (const user of User.byEmail.find({is: "john@example.com"})) {
-     *   console.log(user.name);
-     * }
-     *
-     * // Range query (inclusive)
-     * for (const user of User.byEmail.find({from: "a@", to: "m@"})) {
-     *   console.log(user.email);
-     * }
-     *
-     * // Range query (exclusive)
-     * for (const user of User.byEmail.find({after: "a@", before: "m@"})) {
-     *   console.log(user.email);
-     * }
-     *
-     * // Open-ended ranges
-     * for (const user of User.byEmail.find({from: "m@"})) { // m@ and later
-     *   console.log(user.email);
-     * }
-     *
-     * for (const user of User.byEmail.find({to: "m@"})) { // up to and including m@
-     *   console.log(user.email);
-     * }
-     *
-     * // Reverse iteration
-     * for (const user of User.byEmail.find({reverse: true})) {
-     *   console.log(user.email); // Z to A order
-     * }
-     *
-     * // Multi-field index prefix matching
-     * for (const item of CompositeModel.pk.find({from: ["electronics", "phones"]})) {
-     *   console.log(item.name); // All electronics/phones items
-     * }
-     *
-     * // For single-field indexes, you can use the value directly
-     * for (const user of User.byEmail.find({is: "john@example.com"})) {
-     *   console.log(user.name);
-     * }
-     * ```
-     */
     _computeKeyBounds(opts) {
         let startKey;
         let endKey;
@@ -300,12 +197,15 @@ export class BaseIndex {
     }
     find(opts = {}) {
         const txn = currentTxn();
-        const indexId = this._indexId;
         const bounds = this._computeKeyBounds(opts);
-        if (!bounds)
-            return new IndexRangeIterator(txn, -1, indexId, this);
+        if (!bounds) {
+            if (opts.fetch === 'single')
+                throw new DatabaseError('Expected exactly one result, got none', 'NOT_FOUND');
+            if (opts.fetch === 'first')
+                return undefined;
+            return new IndexRangeIterator(txn, -1, 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;
         if (logLevel >= 3) {
@@ -314,18 +214,27 @@ export class BaseIndex {
         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);
+        const iter = new IndexRangeIterator(txn, iteratorId, this);
+        if (opts.fetch === 'first')
+            return iter.fetch();
+        if (opts.fetch === 'single') {
+            const first = iter.fetch();
+            if (!first)
+                throw new DatabaseError('Expected exactly one result, got none', 'NOT_FOUND');
+            if (iter.fetch() !== undefined)
+                throw new DatabaseError('Expected exactly one result, got multiple', 'NOT_UNIQUE');
+            return first;
+        }
+        return iter;
     }
     /**
-     * Process all matching rows in batched transactions.
+     * Process 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.
+     * Uses the same range options as {@link find}, plus optional row and time
+     * limits that control when the current transaction is committed and a new one starts.
      *
-     * @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
+     * @param opts Query options plus batch limits.
+     * @param callback Called for each matching row inside a transaction.
      */
     async batchProcess(opts = {}, callback) {
         const limitMs = (opts.limitSeconds ?? 1) * 1000;
@@ -362,11 +271,11 @@ export class BaseIndex {
                 finally {
                     lowlevel.closeIterator(iteratorId);
                 }
-                lastRawKey = lastRawKey.slice(); // Copy, as lastRawKey points at OLMDB's internal read-only mmap
+                lastRawKey = lastRawKey.slice();
                 if (reverse)
                     return lastRawKey;
-                const nk = new DataPack(lastRawKey);
-                return nk.increment() ? nk.toUint8Array() : null;
+                const nextKey = new DataPack(lastRawKey);
+                return nextKey.increment() ? nextKey.toUint8Array() : null;
             });
             if (next === null)
                 break;
@@ -374,99 +283,30 @@ export class BaseIndex {
         }
     }
     toString() {
-        return `${this._indexId}:${this._MyModel.tableName}:${this._getTypeName()}[${Array.from(this._fieldTypes.keys()).join(',')}]`;
+        return `${this._indexId}:${this.tableName}:${this._getTypeName()}[${Array.from(this._indexFields.keys()).join(',')}]`;
     }
 }
-function toArray(args) {
-    // Convert single value or array to array format compatible with Partial<ARG_TYPES>
-    return (Array.isArray(args) ? args : [args]);
-}
-/**
- * Primary index that stores the actual model data.
- *
- * @template M - The model class this index belongs to.
- * @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);
-        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
-            };
-        }
+export class PrimaryKey extends BaseIndex {
+    _getTypeName() {
+        return 'primary';
+    }
+    _versionInfoKey(version) {
+        return new DataPack()
+            .write(VERSION_INFO_PREFIX)
+            .write(this._indexId)
+            .write(version)
+            .toUint8Array();
     }
-    /** 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 ? hashFunction(migrateFn) : 0;
-        const currentValueBytes = this._serializeVersionValue();
-        // Scan last 20 version info rows for this primary index
+    async _ensureVersionEntry(currentValueBytes) {
         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
-                );
+                const iteratorId = lowlevel.createIterator(txnId, scanEnd ? toBuffer(scanEnd.toUint8Array()) : undefined, toBuffer(scanStart.toUint8Array()), true);
                 let count = 0;
                 let maxVersion = 0;
-                let found = false;
+                let matchingVersion;
                 try {
                     while (count < 20) {
                         const raw = lowlevel.readIterator(iteratorId);
@@ -474,14 +314,13 @@ export class PrimaryIndex extends BaseIndex {
                             break;
                         count++;
                         const keyPack = new DataPack(new Uint8Array(raw.key));
-                        keyPack.readNumber(); // skip VERSION_INFO_PREFIX
-                        keyPack.readNumber(); // skip indexId
+                        keyPack.readNumber();
+                        keyPack.readNumber();
                         const versionNum = keyPack.readNumber();
                         maxVersion = Math.max(maxVersion, versionNum);
                         const valueBytes = new Uint8Array(raw.value);
                         if (bytesEqual(valueBytes, currentValueBytes)) {
-                            this._currentVersion = versionNum;
-                            found = true;
+                            matchingVersion = versionNum;
                             break;
                         }
                     }
@@ -489,25 +328,18 @@ export class PrimaryIndex extends BaseIndex {
                 finally {
                     lowlevel.closeIterator(iteratorId);
                 }
-                if (found) {
+                if (matchingVersion !== undefined) {
                     lowlevel.abortTransaction(txnId);
-                    return;
+                    return { version: matchingVersion, created: false };
                 }
-                // 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);
+                const version = maxVersion + 1;
+                dbPut(txnId, this._versionInfoKey(version), currentValueBytes);
                 if (logLevel >= 1)
-                    console.log(`[edinburgh] Create version ${this._currentVersion} for ${this}`);
+                    console.log(`[edinburgh] Create version ${version} for ${this}`);
                 const commitResult = lowlevel.commitTransaction(txnId);
                 const commitSeq = typeof commitResult === 'number' ? commitResult : await commitResult;
                 if (commitSeq > 0)
-                    return;
-                // Race - retry
+                    return { version, created: true };
             }
             catch (e) {
                 try {
@@ -518,422 +350,212 @@ export class PrimaryIndex extends BaseIndex {
             }
         }
     }
-    /**
-     * Get a model instance by primary key values.
-     * @param args - The primary key values.
-     * @returns The model instance if found, undefined otherwise.
-     *
-     * @example
-     * ```typescript
-     * const user = User.pk.get("john_doe");
-     * ```
-     */
-    get(...args) {
-        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;
-        }
-        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 {
-                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;
-    }
-    _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)}`);
-        }
-        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);
-    }
-    _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));
-            }
-        }
-        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));
-        }
-        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');
-            }
+    _serializePK(data) {
+        const bytes = new DataPack();
+        bytes.write(this._indexId);
+        for (const [fieldName, fieldType] of this._indexFields.entries()) {
+            fieldType.serialize(data[fieldName], bytes);
         }
+        return bytes;
     }
-    _keyToArray(key) {
+    _pkToArray(key) {
         const bytes = new DataPack(key);
         assert(bytes.readNumber() === this._indexId);
         const result = [];
-        for (const fieldType of this._fieldTypes.values()) {
+        for (const fieldType of this._indexFields.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);
-        }
+    _writePK(txn, primaryKey, data) {
+        const valueBytes = this._serializeValue(data);
         if (logLevel >= 2) {
-            console.log(`[edinburgh] Write ${this} key=${new DataPack(primaryKey)} value=${valueBytes}`);
+            console.log(`[edinburgh] Write ${this} key=${new DataPack(primaryKey)} value=${new DataPack(valueBytes)}`);
         }
-        dbPut(txn.id, primaryKey, valueBytes.toUint8Array());
+        dbPut(txn.id, primaryKey, valueBytes);
     }
-    _delete(txn, primaryKey, _data) {
+    _deletePK(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.
- *
- * @template M - The model class this index belongs to.
- * @template F - The field names that make up this index.
- */
-export class UniqueIndex extends BaseIndex {
-    constructor(MyModel, fieldsOrFn) {
-        super(MyModel, typeof fieldsOrFn === 'function' ? [] : fieldsOrFn);
+function toArray(args) {
+    return (Array.isArray(args) ? args : [args]);
+}
+const SECONDARY_VALUE = new DataPack().write(undefined).toUint8Array();
+export class NonPrimaryIndex extends BaseIndex {
+    _loadPrimary;
+    _resetIndexFieldDescriptors = {};
+    constructor(tableName, fieldsOrFn, _loadPrimary, queueInitialization) {
+        super(tableName, typeof fieldsOrFn === 'function' ? [] : fieldsOrFn);
+        this._loadPrimary = _loadPrimary;
         if (typeof fieldsOrFn === 'function')
             this._computeFn = fieldsOrFn;
-        (this._MyModel._secondaries ||= []).push(this);
-        scheduleInit();
+        queueInitialization();
     }
-    /**
-     * Get a model instance by unique index key values.
-     * @param args - The unique index key values.
-     * @returns The model instance if found, undefined otherwise.
-     *
-     * @example
-     * ```typescript
-     * const userByEmail = User.byEmail.get("john@example.com");
-     * ```
-     */
-    get(...args) {
-        const txn = currentTxn();
-        let keyBuffer = this._argsToKeyBytes(args, false).toUint8Array();
-        let valueBuffer = dbGet(txn.id, keyBuffer);
-        if (logLevel >= 3) {
-            console.log(`[edinburgh] Get ${this} key=${new DataPack(keyBuffer)} result=${valueBuffer}`);
+    async _initializeIndex(fields, reset = false, primaryFieldTypes) {
+        if (reset)
+            this._resetIndexFieldDescriptors = {};
+        await super._initializeIndex(fields, reset, primaryFieldTypes);
+        for (const fieldName of this._indexFields.keys()) {
+            this._resetIndexFieldDescriptors[fieldName] = {
+                writable: true,
+                configurable: true,
+                enumerable: true,
+            };
         }
-        if (!valueBuffer)
-            return;
-        const pk = this._MyModel._primary;
-        const result = pk._get(txn, valueBuffer, true);
-        if (!result)
-            throw new DatabaseError(`Unique index ${this} points at non-existing primary for key: ${args.join(', ')}`, 'CONSISTENCY_ERROR');
-        return result;
-    }
-    _serializeKey(primaryKey, data) {
-        return this._serializeKeyFields(data).toUint8Array();
     }
-    _delete(txn, primaryKey, data) {
+    _buildKeyPacks(data) {
         if (this._computeFn) {
-            for (const value of this._computeFn(data)) {
-                const key = new DataPack().write(this._indexId).write(value).toUint8Array();
-                if (logLevel >= 2)
-                    console.log(`[edinburgh] Delete ${this} fn-key=${key}`);
-                dbDel(txn.id, key);
-            }
-            return;
+            return this._computeFn(data).map((value) => {
+                const bytes = new DataPack();
+                bytes.write(this._indexId);
+                bytes.write(value);
+                return bytes;
+            });
         }
-        if (!this._hasNullIndexValues(data)) {
-            const key = this._serializeKey(primaryKey, data);
-            if (logLevel >= 2) {
-                console.log(`[edinburgh] Delete ${this} key=${key}`);
-            }
+        for (const fieldName of this._indexFields.keys()) {
+            if (data[fieldName] == null)
+                return [];
+        }
+        const bytes = new DataPack();
+        bytes.write(this._indexId);
+        for (const [fieldName, fieldType] of this._indexFields.entries()) {
+            fieldType.serialize(data[fieldName], bytes);
+        }
+        return [bytes];
+    }
+    _serializeKeys(primaryKey, data) {
+        return this._buildKeyPacks(data).map(pack => pack.toUint8Array());
+    }
+    _write(txn, primaryKey, model) {
+        for (const key of this._serializeKeys(primaryKey, model)) {
+            if (logLevel >= 2)
+                console.log(`[edinburgh] Write ${this} key=${new DataPack(key)}`);
+            this._writeKey(txn, key, primaryKey);
+        }
+    }
+    _delete(txn, primaryKey, model) {
+        for (const key of this._serializeKeys(primaryKey, model)) {
+            if (logLevel >= 2)
+                console.log(`[edinburgh] Delete ${this} key=${new DataPack(key)}`);
             dbDel(txn.id, key);
         }
     }
-    _write(txn, primaryKey, data) {
-        if (this._computeFn) {
-            for (const value of this._computeFn(data)) {
-                const key = new DataPack().write(this._indexId).write(value).toUint8Array();
-                if (logLevel >= 2)
-                    console.log(`[edinburgh] Write ${this} fn-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);
-            }
-            return;
+    _update(txn, primaryKey, newData, oldData) {
+        const oldKeys = this._serializeKeys(primaryKey, oldData);
+        const newKeys = this._serializeKeys(primaryKey, newData);
+        if (oldKeys.length === newKeys.length && (oldKeys.length === 0 || bytesEqual(oldKeys[0], newKeys[0]))) {
+            return 0;
         }
-        if (!this._hasNullIndexValues(data)) {
-            const key = this._serializeKey(primaryKey, data);
-            if (logLevel >= 2) {
-                console.log(`[edinburgh] Write ${this} key=${key} value=${new DataPack(primaryKey)}`);
+        const oldKeyMap = new Map();
+        for (const key of oldKeys)
+            oldKeyMap.set(hashBytes(key), key);
+        let changes = 0;
+        for (const key of newKeys) {
+            const hash = hashBytes(key);
+            if (oldKeyMap.has(hash)) {
+                oldKeyMap.delete(hash);
             }
-            if (dbGet(txn.id, key)) {
-                throw new DatabaseError(`Unique constraint violation for ${this} key ${key}`, 'UNIQUE_CONSTRAINT');
+            else {
+                if (logLevel >= 2)
+                    console.log(`[edinburgh] Write ${this} key=${new DataPack(key)}`);
+                this._writeKey(txn, key, primaryKey);
+                changes++;
             }
-            dbPut(txn.id, key, primaryKey);
         }
+        for (const key of oldKeyMap.values()) {
+            if (logLevel >= 2)
+                console.log(`[edinburgh] Delete ${this} key=${new DataPack(key)}`);
+            dbDel(txn.id, key);
+            changes++;
+        }
+        return changes;
+    }
+}
+export class UniqueIndex extends NonPrimaryIndex {
+    constructor(tableName, fieldsOrFn, loadPrimary, queueInitialization) {
+        super(tableName, fieldsOrFn, loadPrimary, queueInitialization);
+    }
+    _getTypeName() {
+        return this._computeFn ? 'fn-unique' : 'unique';
+    }
+    getPK(...args) {
+        const txn = currentTxn();
+        const keyBuffer = this._argsToKeyBytes(args, false).toUint8Array();
+        const valueBuffer = dbGet(txn.id, keyBuffer);
+        if (logLevel >= 3) {
+            console.log(`[edinburgh] Get ${this} key=${new DataPack(keyBuffer)} result=${valueBuffer}`);
+        }
+        if (!valueBuffer)
+            return;
+        const result = this._loadPrimary(txn, valueBuffer, true);
+        if (!result)
+            throw new DatabaseError(`Unique index ${this} points at non-existing primary for key: ${args.join(', ')}`, 'CONSISTENCY_ERROR');
+        return result;
+    }
+    _writeKey(txn, key, primaryKey) {
+        if (dbGet(txn.id, key))
+            throw new DatabaseError(`Unique constraint violation for ${this}`, 'UNIQUE_CONSTRAINT');
+        dbPut(txn.id, key, primaryKey);
     }
     _pairToInstance(txn, keyBuffer, valueBuffer) {
-        // For unique indexes, the value contains the primary key
-        const pk = this._MyModel._primary;
-        const model = pk._get(txn, new Uint8Array(valueBuffer), false);
-        if (!this._computeFn) {
+        const model = this._loadPrimary(txn, new Uint8Array(valueBuffer), false);
+        if (this._indexFields.size > 0) {
             const keyPack = new DataPack(new Uint8Array(keyBuffer));
-            keyPack.readNumber(); // discard index id
-            // _get will have created lazy-load getters for our indexed fields. Let's turn them back into
-            // regular properties:
+            keyPack.readNumber();
             Object.defineProperties(model, this._resetIndexFieldDescriptors);
-            // Set the values for our indexed fields
-            for (const [name, fieldType] of this._fieldTypes.entries()) {
+            for (const [name, fieldType] of this._indexFields.entries()) {
                 model._setLoadedField(name, fieldType.deserialize(keyPack));
             }
         }
+        model._restoreLazyFields?.();
         return model;
     }
-    _getTypeName() {
-        return this._computeFn ? 'fn-unique' : 'unique';
-    }
 }
-// OLMDB does not support storing empty values, so we use a 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.
- *
- * @template M - The model class this index belongs to.
- * @template F - The field names that make up this index.
- */
-export class SecondaryIndex extends BaseIndex {
-    constructor(MyModel, fieldsOrFn) {
-        super(MyModel, typeof fieldsOrFn === 'function' ? [] : fieldsOrFn);
-        if (typeof fieldsOrFn === 'function')
-            this._computeFn = fieldsOrFn;
-        (this._MyModel._secondaries ||= []).push(this);
-        scheduleInit();
+export class SecondaryIndex extends NonPrimaryIndex {
+    constructor(tableName, fieldsOrFn, loadPrimary, queueInitialization) {
+        super(tableName, fieldsOrFn, loadPrimary, queueInitialization);
+    }
+    _getTypeName() {
+        return this._computeFn ? 'fn-secondary' : 'secondary';
     }
     _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 (or skip computed value)
+        keyPack.readNumber();
         const indexFields = new Map();
-        if (this._computeFn) {
-            keyPack.read(); // skip computed value
-        }
-        else {
-            for (const [name, type] of this._fieldTypes.entries()) {
-                indexFields.set(name, type.deserialize(keyPack));
-            }
+        for (const [name, fieldType] of this._indexFields.entries()) {
+            indexFields.set(name, fieldType.deserialize(keyPack));
         }
+        if (this._computeFn)
+            keyPack.read();
         const primaryKey = keyPack.readUint8Array();
-        const model = this._MyModel._primary._get(txn, primaryKey, false);
+        const model = this._loadPrimary(txn, primaryKey, false);
         if (indexFields.size > 0) {
-            // _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);
             }
         }
+        model._restoreLazyFields?.();
         return model;
     }
-    _serializeKey(primaryKey, model) {
-        // index id + index fields + primary key
-        const bytes = super._serializeKeyFields(model);
-        bytes.write(primaryKey);
-        return bytes.toUint8Array();
+    _serializeKeys(primaryKey, data) {
+        return this._buildKeyPacks(data).map(pack => {
+            pack.write(primaryKey);
+            return pack.toUint8Array();
+        });
     }
-    _write(txn, primaryKey, model) {
-        if (this._computeFn) {
-            for (const value of this._computeFn(model)) {
-                const key = new DataPack().write(this._indexId).write(value).write(primaryKey).toUint8Array();
-                if (logLevel >= 2)
-                    console.log(`[edinburgh] Write ${this} fn-key=${key}`);
-                dbPut(txn.id, key, SECONDARY_VALUE);
-            }
-            return;
-        }
-        if (this._hasNullIndexValues(model))
-            return;
-        const key = this._serializeKey(primaryKey, model);
-        if (logLevel >= 2) {
-            console.log(`[edinburgh] Write ${this} key=${key}`);
-        }
+    _writeKey(txn, key, _primaryKey) {
         dbPut(txn.id, key, SECONDARY_VALUE);
     }
-    _delete(txn, primaryKey, model) {
-        if (this._computeFn) {
-            for (const value of this._computeFn(model)) {
-                const key = new DataPack().write(this._indexId).write(value).write(primaryKey).toUint8Array();
-                if (logLevel >= 2)
-                    console.log(`[edinburgh] Delete ${this} fn-key=${key}`);
-                dbDel(txn.id, key);
-            }
-            return;
-        }
-        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 this._computeFn ? 'fn-secondary' : 'secondary';
-    }
-}
-export function primary(MyModel, fields) {
-    return new PrimaryIndex(MyModel, Array.isArray(fields) ? fields : [fields]);
 }
-export function unique(MyModel, fields) {
-    return new UniqueIndex(MyModel, typeof fields === 'string' ? [fields] : fields);
-}
-export function index(MyModel, fields) {
-    return new SecondaryIndex(MyModel, typeof fields === 'string' ? [fields] : fields);
-}
-/**
- * Dump database contents for debugging.
- *
- * Prints all indexes and their data to the console for inspection.
- * This is primarily useful for development and debugging purposes.
- */
 export function dump() {
     const txn = currentTxn();
-    let indexesById = new Map();
-    let versions = new Map();
+    const indexesById = new Map();
+    const versions = new Map();
     console.log("--- edinburgh database dump ---");
     const iteratorId = lowlevel.createIterator(txn.id, undefined, undefined, false);
     try {
@@ -965,38 +587,33 @@ export function dump() {
                 const type = kb.readString();
                 const fields = {};
                 while (kb.readAvailable()) {
-                    const name = kb.read();
-                    if (typeof name !== 'string')
-                        break; // undefined separator or computed hash
-                    fields[name] = deserializeType(kb, 0);
+                    const fieldName = kb.read();
+                    if (typeof fieldName !== 'string')
+                        break;
+                    fields[fieldName] = deserializeType(kb, 0);
                 }
-                const indexId = vb.readNumber();
-                console.log(`* Index definition ${indexId}:${name}:${type}[${Object.keys(fields).join(',')}]`);
-                indexesById.set(indexId, { name, type, fields });
+                const definedIndexId = vb.readNumber();
+                console.log(`* Index definition ${definedIndexId}:${name}:${type}[${Object.keys(fields).join(',')}]`);
+                indexesById.set(definedIndexId, { 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);
-                            }
+                let rowKey = {};
+                let rowValue;
+                for (const [fieldName, fieldType] of Object.entries(index.fields)) {
+                    rowKey[fieldName] = fieldType.deserialize(kb);
+                }
+                if (index.type === 'primary') {
+                    const version = vb.readNumber();
+                    const valueFields = versions.get(indexId)?.get(version);
+                    if (valueFields) {
+                        rowValue = {};
+                        for (const [fieldName, fieldType] of valueFields) {
+                            rowValue[fieldName] = fieldType.deserialize(vb);
                         }
                     }
                 }
-                console.log(`* Row for ${indexId}:${name}:${type}`, rowKey ?? kb, rowValue ?? vb);
+                console.log(`* Row for ${indexId}:${index.name}:${index.type}`, rowKey ?? kb, rowValue ?? vb);
             }
             else {
                 console.log(`* Unhandled '${indexId}' key=${kb} value=${vb}`);