edinburgh 0.4.6 → 0.6.0

package/build/src/models.js

@@ -1,26 +1,16 @@
+import * as lowlevel from "olmdb/lowlevel";
 import { DatabaseError } from "olmdb/lowlevel";
-import { AsyncLocalStorage } from "node:async_hooks";
-import { TypeWrapper, identifier } from "./types.js";
-import { scheduleInit } from "./edinburgh.js";
-export const txnStorage = new AsyncLocalStorage();
+import DataPack from "./datapack.js";
+import { deserializeType, serializeType, TypeWrapper, identifier } from "./types.js";
+import { transact, currentTxn } from "./edinburgh.js";
+import { PrimaryKey, UniqueIndex, SecondaryIndex } from "./indexes.js";
+import { addErrorPath, dbGet, hashBytes, hashFunction } from "./utils.js";
+let nextFakePkHash = -1;
 const PREVENT_PERSIST_DESCRIPTOR = {
     get() {
         throw new DatabaseError("Operation not allowed after preventPersist()", "NO_PERSIST");
     },
 };
-/**
- * Returns the current transaction from AsyncLocalStorage.
- * Throws if called outside a transact() callback.
- * @internal
- */
-export function currentTxn() {
-    const txn = txnStorage.getStore();
-    if (!txn)
-        throw new DatabaseError("No active transaction. Operations must be performed within a transact() callback.", 'NO_TRANSACTION');
-    return txn;
-}
-import { PrimaryIndex } from "./indexes.js";
-import { addErrorPath, logLevel, dbGet, hashBytes, bytesEqual } from "./utils.js";
 /**
  * Create a field definition for a model property.
  *
@@ -29,16 +19,16 @@ import { addErrorPath, logLevel, dbGet, hashBytes, bytesEqual } from "./utils.js
  * This allows for both runtime introspection and compile-time type safety.
  *
  * @template T - The field type.
- * @param type - The type wrapper for this field.
- * @param options - Additional field configuration options.
+ * @param type The type wrapper for this field.
+ * @param options Additional field configuration options.
  * @returns The field value (typed as T, but actually returns FieldConfig<T>).
  *
  * @example
  * ```typescript
- * class User extends E.Model<User> {
+ * const User = E.defineModel("User", class {
  *   name = E.field(E.string, {description: "User's full name"});
  *   age = E.field(E.opt(E.number), {description: "User's age", default: 25});
- * }
+ * });
  * ```
  */
 export function field(type, options = {}) {
@@ -46,84 +36,412 @@ export function field(type, options = {}) {
     options.type = type;
     return options;
 }
-// Model registration and initialization
-export const modelRegistry = {};
 function isObjectEmpty(obj) {
-    for (let _ of Object.keys(obj)) {
+    for (const _ of Object.keys(obj)) {
         return false;
     }
     return true;
 }
+function copyStaticMembersFromClassChain(target, source) {
+    for (let current = source; current && current !== Function.prototype; current = Object.getPrototypeOf(current)) {
+        for (const key of Object.getOwnPropertyNames(current)) {
+            if (key === 'length' || key === 'name' || key === 'prototype')
+                continue;
+            if (Object.prototype.hasOwnProperty.call(target, key))
+                continue;
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(current, key));
+        }
+    }
+}
+// Model registration and initialization
+export const modelRegistry = {};
+export const pendingModelInits = new Set();
+// These static members are attached dynamically in defineModel(), so 'declare' tells TypeScript
+// they exist at runtime without emitting duplicate class fields that would shadow those assignments.
+class ModelClassRuntime extends PrimaryKey {
+    // Cached list of non-primary fields used for value serialization.
+    _nonKeyFields;
+    // Lazy getter/setter descriptors installed on unloaded non-key fields.
+    _lazyDescriptors = {};
+    // Writable descriptors temporarily installed before hydrating value fields.
+    _resetDescriptors = {};
+    // Frozen descriptors applied to primary-key fields after key materialization.
+    _freezePrimaryKeyDescriptors = {};
+    // Active schema version number for value encoding.
+    _currentVersion;
+    // Hash of the active migrate() function for schema identity.
+    _currentMigrateHash;
+    // Cached historical schema metadata for lazy migration of old rows.
+    _versions = new Map();
+    _serializeVersionValue() {
+        const fields = [];
+        for (const fieldName of this._nonKeyFields) {
+            const tp = new DataPack();
+            serializeType(this.fields[fieldName].type, tp);
+            fields.push([fieldName, tp.toUint8Array()]);
+        }
+        return new DataPack().write({
+            migrateHash: this._currentMigrateHash,
+            fields,
+            secondaryKeys: new Set(Object.values(this._secondaries || {}).map(sec => sec._signature)),
+        }).toUint8Array();
+    }
+    async _initialize(reset = false) {
+        const allFieldTypes = new Map();
+        for (const [fieldName, fieldConfig] of Object.entries(this.fields)) {
+            allFieldTypes.set(fieldName, fieldConfig.type);
+        }
+        await super._initializeIndex(allFieldTypes, reset);
+        if (reset || this._nonKeyFields === undefined) {
+            this._nonKeyFields = Object.keys(this.fields).filter(fieldName => !this._indexFields.has(fieldName));
+            this._lazyDescriptors = {};
+            this._resetDescriptors = {};
+            this._freezePrimaryKeyDescriptors = {};
+            for (const fieldName of this._nonKeyFields) {
+                this._lazyDescriptors[fieldName] = {
+                    configurable: true,
+                    enumerable: true,
+                    get() {
+                        this.constructor._lazyLoad(this);
+                        return this[fieldName];
+                    },
+                    set(value) {
+                        this.constructor._lazyLoad(this);
+                        this[fieldName] = value;
+                    },
+                };
+                this._resetDescriptors[fieldName] = {
+                    writable: true,
+                    enumerable: true,
+                };
+            }
+            for (const fieldName of this._indexFields.keys()) {
+                this._freezePrimaryKeyDescriptors[fieldName] = {
+                    writable: false,
+                    enumerable: true,
+                };
+            }
+        }
+        for (const sec of Object.values(this._secondaries || {})) {
+            await sec._initializeIndex(allFieldTypes, reset, this._indexFields);
+        }
+        const migrateFn = this.migrate;
+        this._currentMigrateHash = migrateFn ? hashFunction(migrateFn) : 0;
+        const currentValueBytes = this._serializeVersionValue();
+        this._currentVersion = (await this._ensureVersionEntry(currentValueBytes)).version;
+    }
+    _getSecondary(name) {
+        const index = this._secondaries?.[name];
+        if (!index)
+            throw new DatabaseError(`Unknown index '${name}' on model '${this.tableName}'`, 'INIT_ERROR');
+        return index;
+    }
+    _get(txn, args, loadNow) {
+        let key;
+        let keyParts;
+        if (args instanceof Uint8Array) {
+            key = args;
+        }
+        else {
+            key = this._argsToKeyBytes(args, false).toUint8Array();
+            keyParts = args;
+        }
+        const keyHash = hashBytes(key);
+        const cached = txn.instances.get(keyHash);
+        if (cached) {
+            if (loadNow && loadNow !== true) {
+                Object.defineProperties(cached, this._resetDescriptors);
+                this._loadValueFields(cached, loadNow);
+            }
+            return cached;
+        }
+        let valueBuffer;
+        if (loadNow) {
+            if (loadNow === true) {
+                valueBuffer = dbGet(txn.id, key);
+                if (!valueBuffer)
+                    return;
+            }
+            else {
+                valueBuffer = loadNow;
+            }
+        }
+        const model = Object.create(this.prototype);
+        model._txn = txn;
+        model._oldValues = {};
+        txn.instances.set(keyHash, model);
+        if (keyParts) {
+            let i = 0;
+            for (const fieldName of this._indexFields.keys()) {
+                model._setLoadedField(fieldName, keyParts[i++]);
+            }
+        }
+        else {
+            const keyPack = new DataPack(key);
+            keyPack.readNumber();
+            for (const [fieldName, fieldType] of this._indexFields.entries()) {
+                model._setLoadedField(fieldName, fieldType.deserialize(keyPack));
+            }
+        }
+        model._setPrimaryKey(key, keyHash);
+        if (valueBuffer) {
+            this._loadValueFields(model, valueBuffer);
+        }
+        else {
+            Object.defineProperties(model, this._lazyDescriptors);
+        }
+        return model;
+    }
+    _lazyLoad(model) {
+        const key = model._primaryKey;
+        const valueBuffer = dbGet(model._txn.id, key);
+        if (!valueBuffer)
+            throw new DatabaseError(`Lazy-loaded ${this.tableName}#${key} does not exist`, 'LAZY_FAIL');
+        Object.defineProperties(model, this._resetDescriptors);
+        this._loadValueFields(model, valueBuffer);
+    }
+    /**
+     * Load a model by primary key inside the current transaction.
+     *
+     * @returns The matching model, or `undefined` if no row exists.
+     */
+    get(...args) {
+        return this._get(currentTxn(), args, true);
+    }
+    /**
+     * Load a model by primary key without fetching its non-key fields immediately.
+     *
+     * Accessing a lazy field later will load the remaining fields transparently.
+     */
+    getLazy(...args) {
+        return this._get(currentTxn(), args, false);
+    }
+    _pairToInstance(txn, keyBuffer, valueBuffer) {
+        return this._get(txn, new Uint8Array(keyBuffer), new Uint8Array(valueBuffer));
+    }
+    /**
+     * Load an existing instance by primary key and update it, or create a new one.
+      * If a row already exists, its non-primary-key fields are updated in place.
+      * Otherwise, a new instance is created with `obj` as its initial properties.
+     *
+     * @param obj Partial model data that **must** include every primary key field.
+      * @returns The loaded-and-updated or newly created instance.
+     */
+    replaceInto(obj) {
+        const keyArgs = [];
+        for (const fieldName of this._indexFields.keys()) {
+            if (!(fieldName in obj)) {
+                throw new DatabaseError(`replaceInto: missing primary key field '${fieldName}'`, "MISSING_PRIMARY_KEY");
+            }
+            keyArgs.push(obj[fieldName]);
+        }
+        const existing = this.get(...keyArgs);
+        if (existing) {
+            for (const key in obj) {
+                if (!this._indexFields.has(key)) {
+                    existing[key] = obj[key];
+                }
+            }
+            return existing;
+        }
+        return new this(obj);
+    }
+    /**
+     * Look up a model through a named unique index.
+     *
+     * @param name The name from the model's `unique` definition.
+     * @param args The unique-index key values.
+     * @returns The matching model instance, if any.
+     */
+    getBy(name, ...args) {
+        return this._getSecondary(name).getPK(...args);
+    }
+    findBy(name, opts) {
+        return this._getSecondary(name).find(opts);
+    }
+    /**
+     * Process rows from a named unique or secondary index in batched transactions.
+     *
+     * Uses the same range options as `findBy()`, plus batch limits.
+     */
+    batchProcessBy(name, opts, callback) {
+        return this._getSecondary(name).batchProcess(opts, callback);
+    }
+    _loadValueFields(model, valueArray) {
+        const valuePack = new DataPack(valueArray);
+        const version = valuePack.readNumber();
+        if (version === this._currentVersion) {
+            for (const fieldName of this._nonKeyFields) {
+                model._setLoadedField(fieldName, this.fields[fieldName].type.deserialize(valuePack));
+            }
+        }
+        else {
+            this._migrateValueFields(model, version, valuePack);
+        }
+    }
+    _loadVersionInfo(txnId, version) {
+        let info = this._versions.get(version);
+        if (info)
+            return info;
+        const key = this._versionInfoKey(version);
+        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;
+    }
+    _migrateValueFields(model, version, valuePack) {
+        const versionInfo = this._loadVersionInfo(model._txn.id, version);
+        const record = {};
+        for (const [name] of this._indexFields.entries())
+            record[name] = model[name];
+        for (const [name, type] of versionInfo.nonKeyFields.entries()) {
+            record[name] = type.deserialize(valuePack);
+        }
+        const migrateFn = this.migrate;
+        if (migrateFn)
+            migrateFn(record);
+        for (const fieldName of this._nonKeyFields) {
+            if (fieldName in record) {
+                model._setLoadedField(fieldName, record[fieldName]);
+            }
+            else if (fieldName in model) {
+                model._setLoadedField(fieldName, model[fieldName]);
+            }
+            else {
+                throw new DatabaseError(`Field ${fieldName} is missing in migrated data for ${model}`, 'MIGRATION_ERROR');
+            }
+        }
+    }
+    _serializeValue(data) {
+        const valueBytes = new DataPack();
+        valueBytes.write(this._currentVersion);
+        for (const fieldName of this._nonKeyFields) {
+            const fieldConfig = this.fields[fieldName];
+            fieldConfig.type.serialize(data[fieldName], valueBytes);
+        }
+        return valueBytes.toUint8Array();
+    }
+}
+/**
+ * Runtime base constructor for model classes returned by `defineModel()`.
+ *
+ * Prefer the `ModelClass` type alias for annotations and the result of
+ * `defineModel()` for concrete model classes.
+ */
+export const ModelClass = ModelClassRuntime;
 /**
  * Register a model class with the Edinburgh ORM system.
  *
- * @template T - The model class type.
- * @param MyModel - The model class to register.
- * @returns The enhanced model class with ORM capabilities.
+ * Converts a plain class into a fully-featured model with database persistence,
+ * typed fields, primary key access, and optional secondary and unique indexes.
  *
- * @example
- * ```typescript
- * ⁣@E.registerModel
- * class User extends E.Model<User> {
- *   static pk = E.index(User, ["id"], "primary");
- *   id = E.field(E.identifier);
- *   name = E.field(E.string);
- * }
- * ```
+ * @param tableName The database table name for this model.
+ * @param cls A plain class whose properties use E.field().
+ * @param opts Registration options.
+ * @param opts.pk Primary key field name or array of field names.
+ * @param opts.unique Named unique index specifications (field name, field array, or compute function).
+ * @param opts.index Named secondary index specifications (field name, field array, or compute function).
+ * @param opts.override Replace a previous model with the same table name.
+ * @returns The enhanced model constructor.
  */
-export function registerModel(MyModel) {
-    const MockModel = getMockModel(MyModel);
-    // Copy own static methods/properties
-    for (const name of Object.getOwnPropertyNames(MyModel)) {
-        if (name !== 'length' && name !== 'prototype' && name !== 'name' && name !== 'mock' && name !== 'override') {
-            MockModel[name] = MyModel[name];
-        }
-    }
-    MockModel.tableName ||= MyModel.name;
-    // Register the constructor by name
+export function defineModel(tableName, cls, opts) {
+    Object.setPrototypeOf(cls.prototype, ModelBase.prototype);
+    const MockModel = function (initial, txn = currentTxn()) {
+        this._txn = txn;
+        txn.instances.set(nextFakePkHash--, this);
+        if (initial)
+            Object.assign(this, initial);
+    };
+    const normalizeSpec = (spec) => typeof spec === 'string' ? [spec] : spec;
+    const queueInitialization = () => { pendingModelInits.add(MockModel); };
+    const loadPrimary = (txn, primaryKey, loadNow) => MockModel._get(txn, primaryKey, loadNow);
+    cls.prototype.constructor = MockModel;
+    Object.setPrototypeOf(MockModel, ModelClassRuntime.prototype);
+    MockModel.prototype = cls.prototype;
+    copyStaticMembersFromClassChain(MockModel, cls);
+    MockModel.tableName = tableName;
     if (MockModel.tableName in modelRegistry) {
-        if (!MyModel.override) {
+        if (!opts?.override) {
             throw new DatabaseError(`Model with table name '${MockModel.tableName}' already registered`, 'INIT_ERROR');
         }
         delete modelRegistry[MockModel.tableName];
     }
-    modelRegistry[MockModel.tableName] = MockModel;
-    return MockModel;
-}
-export function getMockModel(OrgModel) {
-    const AnyOrgModel = OrgModel;
-    if (AnyOrgModel._isMock)
-        return OrgModel;
-    if (AnyOrgModel._mock)
-        return AnyOrgModel._mock;
-    const MockModel = function (initial, txn = currentTxn()) {
-        // This constructor should only be called when the user does 'new Model'. We'll bypass this when
-        // loading objects. Add to 'instances', so the object will be saved.
-        this._txn = txn;
-        txn.instances.add(this);
-        if (initial) {
-            Object.assign(this, initial);
+    const instance = new cls();
+    if (!opts?.pk && !instance.id) {
+        instance.id = { type: identifier };
+    }
+    MockModel.fields = {};
+    for (const key in instance) {
+        const value = instance[key];
+        if (value && value.type instanceof TypeWrapper) {
+            MockModel.fields[key] = value;
+            const defObj = value.default === undefined ? value.type : value;
+            const def = defObj.default;
+            if (typeof def === 'function') {
+                Object.defineProperty(MockModel.prototype, key, {
+                    get() {
+                        return (this[key] = def.call(defObj, this));
+                    },
+                    set(val) {
+                        Object.defineProperty(this, key, {
+                            value: val,
+                            configurable: true,
+                            writable: true,
+                            enumerable: true,
+                        });
+                    },
+                    configurable: true,
+                });
+            }
+            else if (def !== undefined) {
+                MockModel.prototype[key] = def;
+            }
         }
-    };
-    // We want .constructor to point at our fake constructor function.
-    OrgModel.prototype.constructor = MockModel;
-    // Copy the prototype chain for the constructor as well as for instantiated objects
-    Object.setPrototypeOf(MockModel, Object.getPrototypeOf(OrgModel));
-    MockModel.prototype = OrgModel.prototype;
-    MockModel._isMock = true;
-    MockModel._original = OrgModel;
-    AnyOrgModel._mock = MockModel;
-    scheduleInit();
+    }
+    const primaryFields = opts?.pk ? (Array.isArray(opts.pk) ? opts.pk : [opts.pk]) : ['id'];
+    MockModel._indexFields = new Map();
+    for (const fieldName of primaryFields) {
+        const fieldConfig = MockModel.fields[fieldName];
+        if (!fieldConfig) {
+            throw new DatabaseError(`Unknown primary key field '${fieldName}' on model '${tableName}'`, 'INIT_ERROR');
+        }
+        MockModel._indexFields.set(fieldName, fieldConfig.type);
+    }
+    MockModel._secondaries = {};
+    MockModel._lazyDescriptors = {};
+    MockModel._resetDescriptors = {};
+    MockModel._freezePrimaryKeyDescriptors = {};
+    MockModel._versions = new Map();
+    if (opts?.unique) {
+        for (const [name, spec] of Object.entries(opts.unique)) {
+            MockModel._secondaries[name] = new UniqueIndex(tableName, normalizeSpec(spec), loadPrimary, queueInitialization);
+        }
+    }
+    if (opts?.index) {
+        for (const [name, spec] of Object.entries(opts.index)) {
+            MockModel._secondaries[name] = new SecondaryIndex(tableName, normalizeSpec(spec), loadPrimary, queueInitialization);
+        }
+    }
+    modelRegistry[MockModel.tableName] = MockModel;
+    pendingModelInits.add(MockModel);
     return MockModel;
 }
-// Model base class and related symbols/state
-const INIT_INSTANCE_SYMBOL = Symbol();
 /**
  * Base class for all database models in the Edinburgh ORM.
  *
  * Models represent database entities with typed fields, automatic serialization,
- * change tracking, and relationship management. All model classes should extend
- * this base class and be decorated with `@E.registerModel`.
+ * change tracking, and relationship management. Model classes are created using
+ * `E.defineModel()`.
  *
  * ### Schema Evolution
  *
@@ -149,38 +467,27 @@ const INIT_INSTANCE_SYMBOL = Symbol();
  *
  * - **`static migrate(record)`**: Called when deserializing rows written with an older schema
  *   version. Receives a plain record object; mutate it in-place to match the current schema.
- *   See {@link Model.migrate}.
  *
  * - **`preCommit()`**: Called on each modified instance right before the transaction commits.
  *   Useful for computing derived fields, enforcing cross-field invariants, or creating related
- *   instances. See {@link Model.preCommit}.
- *
- * @template SUB - The concrete model subclass (for proper typing).
+ *   instances.
  *
  * @example
  * ```typescript
- * ⁣@E.registerModel
- * class User extends E.Model<User> {
- *   static pk = E.primary(User, "id");
- *
+ * const User = E.defineModel("User", class {
  *   id = E.field(E.identifier);
  *   name = E.field(E.string);
  *   email = E.field(E.string);
- *
- *   static byEmail = E.unique(User, "email");
- * }
+ * }, {
+ *   pk: "id",
+ *   unique: { email: "email" },
+ * });
+ * // Optional: declare a companion type so `let u: User` works.
+ * // Not needed if you only use `new User()`, `User.find()`, etc.
+ * type User = InstanceType<typeof User>;
  * ```
  */
-export class Model {
-    static _primary;
-    /** @internal All non-primary indexes for this model. */
-    static _secondaries;
-    /** The database table name (defaults to class name). */
-    static tableName;
-    /** When true, registerModel replaces an existing model with the same tableName. */
-    static override;
-    /** Field configuration metadata. */
-    static fields;
+export class ModelBase {
     /*
      * IMPORTANT: We cannot use instance property initializers here, because we will be
      * initializing the class through a fake constructor that will skip these. This is
@@ -190,92 +497,13 @@ export class Model {
      * @internal
      * - _oldValues===undefined: New instance, not yet saved.
      * - _oldValues===null: Instance is to be deleted.
+     * - _oldValues===false: Instance excluded from persistence (preventPersist).
      * - _oldValues is an object: Loaded (possibly only partial, still lazy) from disk, _oldValues contains (partial) old values
      */
     _oldValues;
     _primaryKey;
     _primaryKeyHash;
     _txn;
-    constructor(initial = {}) {
-        // This constructor will only be called once, from `initModels`. All other instances will
-        // be created by the 'fake' constructor. The typing for `initial` *is* important though.
-        if (initial === INIT_INSTANCE_SYMBOL)
-            return;
-        throw new DatabaseError("The model needs a @E.registerModel decorator", 'INIT_ERROR');
-    }
-    /**
-     * Transform the model's `E.field` properties into the appropriate JavaScript properties. Normally this is done
-     * automatically when using `transact()`, but in case you need to access `Model.fields` directly before the first
-     * transaction, you can call this method manually.
-     */
-    static initFields(reset) {
-        const MockModel = getMockModel(this);
-        if (reset) {
-            MockModel._primary._indexId = undefined;
-            MockModel._primary._versions.clear();
-            for (const sec of MockModel._secondaries || [])
-                sec._indexId = undefined;
-        }
-        if (MockModel.fields)
-            return;
-        // First-time init: gather field configs from a temporary instance of the original class.
-        const OrgModel = MockModel._original || this;
-        const instance = new OrgModel(INIT_INSTANCE_SYMBOL);
-        // If no primary key exists, create one using 'id' field
-        if (!MockModel._primary) {
-            if (!instance.id) {
-                instance.id = { type: identifier };
-            }
-            // @ts-ignore-next-line - `id` is not part of the type, but the user probably shouldn't touch it anyhow
-            new PrimaryIndex(MockModel, ['id']);
-        }
-        MockModel.fields = {};
-        for (const key in instance) {
-            const value = instance[key];
-            // Check if this property contains field metadata
-            if (value && value.type instanceof TypeWrapper) {
-                // Set the configuration on the constructor's `fields` property
-                MockModel.fields[key] = value;
-                // Set default value on the prototype
-                const defObj = value.default === undefined ? value.type : value;
-                const def = defObj.default;
-                if (typeof def === 'function') {
-                    // The default is a function. We'll define a getter on the property in the model prototype,
-                    // and once it is read, we'll run the function and set the value as a plain old property
-                    // on the instance object.
-                    Object.defineProperty(MockModel.prototype, key, {
-                        get() {
-                            // This will call set(), which will define the property on the instance.
-                            return (this[key] = def.call(defObj, this));
-                        },
-                        set(val) {
-                            Object.defineProperty(this, key, {
-                                value: val,
-                                configurable: true,
-                                writable: true,
-                                enumerable: true,
-                            });
-                        },
-                        configurable: true,
-                    });
-                }
-                else if (def !== undefined) {
-                    MockModel.prototype[key] = def;
-                }
-            }
-        }
-        if (logLevel >= 1) {
-            console.log(`[edinburgh] Registered model ${MockModel.tableName} with fields: ${Object.keys(MockModel.fields).join(' ')}`);
-        }
-    }
-    static async _loadCreateIndexes() {
-        const MockModel = getMockModel(this);
-        // Always run index inits (idempotent, skip if already initialized)
-        await MockModel._primary._delayedInit();
-        for (const sec of MockModel._secondaries || [])
-            await sec._delayedInit();
-        await MockModel._primary._initVersioning();
-    }
     _setLoadedField(fieldName, value) {
         const oldValues = this._oldValues;
         if (oldValues.hasOwnProperty(fieldName))
@@ -290,13 +518,25 @@ export class Model {
             oldValues[fieldName] = value;
         }
     }
+    _restoreLazyFields() {
+        const oldValues = this._oldValues;
+        if (!oldValues || oldValues === null)
+            return;
+        for (const [fieldName, descriptor] of Object.entries(this.constructor._lazyDescriptors)) {
+            if (!oldValues.hasOwnProperty(fieldName)) {
+                Object.defineProperty(this, fieldName, descriptor);
+            }
+        }
+    }
     /**
      * @returns The primary key for this instance.
      */
     getPrimaryKey() {
         let key = this._primaryKey;
         if (key === undefined) {
-            key = this.constructor._primary._serializeKeyFields(this).toUint8Array();
+            if (this._oldValues === false)
+                throw new DatabaseError("Operation not allowed after preventPersist()", "NO_PERSIST");
+            key = this.constructor._serializePK(this).toUint8Array();
             this._setPrimaryKey(key);
         }
         return key;
@@ -304,7 +544,7 @@ export class Model {
     _setPrimaryKey(key, hash) {
         this._primaryKey = key;
         this._primaryKeyHash = hash ?? hashBytes(key);
-        Object.defineProperties(this, this.constructor._primary._freezePrimaryKeyDescriptors);
+        Object.defineProperties(this, this.constructor._freezePrimaryKeyDescriptors);
     }
     /**
      * @returns A 53-bit positive integer non-cryptographic hash of the primary key, or undefined if not yet saved.
@@ -315,19 +555,21 @@ export class Model {
         return this._primaryKeyHash;
     }
     isLazyField(field) {
-        const descr = this.constructor._primary._lazyDescriptors[field];
-        return !!(descr && 'get' in descr && descr.get === Reflect.getOwnPropertyDescriptor(this, field)?.get);
+        const oldValues = this._oldValues;
+        return !!(oldValues && oldValues !== null && field in this.constructor._lazyDescriptors && !oldValues.hasOwnProperty(field));
     }
     _write(txn) {
         const oldValues = this._oldValues;
+        if (oldValues === false)
+            return; // preventPersist() was called
         if (oldValues === null) { // Delete instance
             const pk = this._primaryKey;
             // Temporarily restore _oldValues so computed indexes can trigger lazy loads
             this._oldValues = {};
-            for (const index of this.constructor._secondaries || []) {
+            for (const index of Object.values(this.constructor._secondaries || {})) {
                 index._delete(txn, pk, this);
             }
-            this.constructor._primary._delete(txn, pk, this);
+            this.constructor._deletePK(txn, pk, this);
             return "deleted";
         }
         if (oldValues === undefined) { // Create instance
@@ -338,9 +580,9 @@ export class Model {
                 throw new DatabaseError("Unique constraint violation", "UNIQUE_CONSTRAINT");
             }
             // Insert the primary index
-            this.constructor._primary._write(txn, pk, this);
+            this.constructor._writePK(txn, pk, this);
             // Insert all secondaries
-            for (const index of this.constructor._secondaries || []) {
+            for (const index of Object.values(this.constructor._secondaries || {})) {
                 index._write(txn, pk, this);
             }
             return "created";
@@ -349,8 +591,9 @@ export class Model {
         // We're doing an update. Note that we may still be in a lazy state, and we don't want to load
         // the whole object just to see if something changed.
         // Add old values of changed fields to 'changed'.
-        const fields = this.constructor.fields;
-        let changed = {};
+        const changed = {};
+        const cls = this.constructor;
+        const fields = cls.fields;
         for (const fieldName in oldValues) {
             const oldValue = oldValues[fieldName];
             const newValue = this[fieldName];
@@ -361,7 +604,7 @@ export class Model {
         if (isObjectEmpty(changed))
             return; // No changes, nothing to do
         // Make sure primary has not been changed
-        for (const field of this.constructor._primary._fieldTypes.keys()) {
+        for (const field of cls._indexFields.keys()) {
             if (changed.hasOwnProperty(field)) {
                 throw new DatabaseError(`Cannot modify primary key field: ${field}`, "CHANGE_PRIMARY");
             }
@@ -371,27 +614,10 @@ export class Model {
         this.validate(true);
         // Update the primary index
         const pk = this._primaryKey;
-        this.constructor._primary._write(txn, pk, this);
+        cls._writePK(txn, pk, this);
         // Update any secondaries with changed fields
-        for (const index of this.constructor._secondaries || []) {
-            if (index._computeFn) {
-                // Computed indexes may depend on any field — compare serialized keys
-                const oldKeyBytes = index._serializeKeyFields(oldValues).toUint8Array();
-                const newKeyBytes = index._serializeKeyFields(this).toUint8Array();
-                if (!bytesEqual(oldKeyBytes, newKeyBytes)) {
-                    index._delete(txn, pk, oldValues);
-                    index._write(txn, pk, this);
-                }
-            }
-            else {
-                for (const field of index._fieldTypes.keys()) {
-                    if (changed.hasOwnProperty(field)) {
-                        index._delete(txn, pk, oldValues);
-                        index._write(txn, pk, this);
-                        break;
-                    }
-                }
-            }
+        for (const index of Object.values(cls._secondaries || {})) {
+            index._update(txn, pk, this, oldValues);
         }
         return changed;
     }
@@ -402,56 +628,20 @@ export class Model {
      *
      * @example
      * ```typescript
-     * const user = User.load("user123");
+     * const user = User.get("user123");
      * user.name = "New Name";
      * user.preventPersist(); // Changes won't be saved
      * ```
      */
     preventPersist() {
-        this._txn.instances.delete(this);
+        if (this._oldValues === undefined && this._primaryKey !== undefined) {
+            throw new DatabaseError("Cannot preventPersist() after PK has been used", "INVALID");
+        }
+        this._oldValues = false;
         // Have access to '_txn' throw a descriptive error:
         Object.defineProperty(this, "_txn", PREVENT_PERSIST_DESCRIPTOR);
         return this;
     }
-    /**
-     * Find all instances of this model in the database, ordered by primary key.
-     * @param opts - Optional parameters.
-     * @param opts.reverse - If true, iterate in reverse order.
-     * @returns An iterator.
-     */
-    static findAll(opts) {
-        return this._primary.find(opts);
-    }
-    /**
-     * Load an existing instance by primary key and update it, or create a new one.
-     *
-     * The provided object must contain all primary key fields. If a matching row exists,
-     * the remaining properties from `obj` are set on the loaded instance. Otherwise a
-     * new instance is created with `obj` as its initial properties.
-     *
-     * @param obj - Partial model data that **must** include every primary key field.
-     * @returns The loaded-and-updated or newly created instance.
-     */
-    static replaceInto(obj) {
-        const pk = this._primary;
-        const keyArgs = [];
-        for (const fieldName of pk._fieldTypes.keys()) {
-            if (!(fieldName in obj)) {
-                throw new DatabaseError(`replaceInto: missing primary key field '${fieldName}'`, "MISSING_PRIMARY_KEY");
-            }
-            keyArgs.push(obj[fieldName]);
-        }
-        const existing = pk.get(...keyArgs);
-        if (existing) {
-            for (const key in obj) {
-                if (!pk._fieldTypes.has(key)) {
-                    existing[key] = obj[key];
-                }
-            }
-            return existing;
-        }
-        return new this(obj);
-    }
     /**
      * Delete this model instance from the database.
      *
@@ -459,18 +649,18 @@ export class Model {
      *
      * @example
      * ```typescript
-     * const user = User.load("user123");
+     * const user = User.get("user123");
      * user.delete(); // Removes from database
      * ```
      */
     delete() {
         if (this._oldValues === undefined)
-            throw new DatabaseError("Cannot delete unsaved instance", "NOT_SAVED");
+            throw new DatabaseError("Cannot delete unsaved instance", "INVALID");
         this._oldValues = null;
     }
     /**
      * Validate all fields in this model instance.
-     * @param raise - If true, throw on first validation error.
+     * @param raise If true, throw on first validation error.
      * @returns Array of validation errors (empty if valid).
      *
      * @example
@@ -484,10 +674,11 @@ export class Model {
      */
     validate(raise = false) {
         const errors = [];
-        for (const [key, fieldConfig] of Object.entries(this.constructor.fields)) {
+        const cls = this.constructor;
+        for (const [key, fieldConfig] of Object.entries(cls.fields)) {
             let e = fieldConfig.type.getError(this[key]);
             if (e) {
-                e = addErrorPath(e, this.constructor.tableName + "." + key);
+                e = addErrorPath(e, cls.tableName + "." + key);
                 if (raise)
                     throw e;
                 errors.push(e);
@@ -513,7 +704,7 @@ export class Model {
             return "deleted";
         if (this._oldValues === undefined)
             return "created";
-        for (const [key, descr] of Object.entries(this.constructor._primary._lazyDescriptors)) {
+        for (const [key, descr] of Object.entries(this.constructor._lazyDescriptors)) {
             if (descr && 'get' in descr && descr.get === Reflect.getOwnPropertyDescriptor(this, key)?.get) {
                 return "lazy";
             }
@@ -521,12 +712,49 @@ export class Model {
         return "loaded";
     }
     toString() {
-        const primary = this.constructor._primary;
-        const pk = primary._keyToArray(this._primaryKey || primary._serializeKeyFields(this).toUint8Array(false));
-        return `{Model:${this.constructor.tableName} ${this.getState()} ${pk}}`;
+        const cls = this.constructor;
+        const pk = cls._pkToArray(this._primaryKey || cls._serializePK(this).toUint8Array(false));
+        return `{Model:${cls.tableName} ${this.getState()} ${pk}}`;
     }
     [Symbol.for('nodejs.util.inspect.custom')]() {
         return this.toString();
     }
 }
+/**
+ * Delete every key/value entry in the database and reinitialize all registered models.
+ *
+ * This clears rows, index metadata, and schema-version records. It is mainly useful
+ * for tests, local resets, or tooling that needs a completely empty database.
+ */
+export async function deleteEverything() {
+    let done = false;
+    while (!done) {
+        await transact(() => {
+            const txn = currentTxn();
+            const iteratorId = lowlevel.createIterator(txn.id, undefined, undefined, false);
+            const deadline = Date.now() + 150;
+            let count = 0;
+            try {
+                while (true) {
+                    const raw = lowlevel.readIterator(iteratorId);
+                    if (!raw) {
+                        done = true;
+                        break;
+                    }
+                    lowlevel.del(txn.id, raw.key);
+                    if (++count >= 4096 || Date.now() >= deadline)
+                        break;
+                }
+            }
+            finally {
+                lowlevel.closeIterator(iteratorId);
+            }
+        });
+    }
+    for (const model of Object.values(modelRegistry)) {
+        pendingModelInits.delete(model);
+        await model._initialize(true);
+    }
+}
+export const Model = ModelBase;
 //# sourceMappingURL=models.js.map