edinburgh 0.5.0 → 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, UniqueIndex, SecondaryIndex } from "./indexes.js";
-import { addErrorPath, dbGet, hashBytes } from "./utils.js";
 /**
  * Create a field definition for a model property.
  *
@@ -29,13 +19,13 @@ import { addErrorPath, dbGet, hashBytes } 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
- * const User = E.defineModel(class {
+ * 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});
  * });
@@ -46,33 +36,340 @@ 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;
 }
-let autoTableNameId = 0;
-export function defineModel(cls, opts) {
-    Object.setPrototypeOf(cls.prototype, Model.prototype);
+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.
+ *
+ * Converts a plain class into a fully-featured model with database persistence,
+ * typed fields, primary key access, and optional secondary and unique indexes.
+ *
+ * @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 defineModel(tableName, cls, opts) {
+    Object.setPrototypeOf(cls.prototype, ModelBase.prototype);
     const MockModel = function (initial, txn = currentTxn()) {
         this._txn = txn;
-        txn.instances.add(this);
+        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, Model);
+    Object.setPrototypeOf(MockModel, ModelClassRuntime.prototype);
     MockModel.prototype = cls.prototype;
-    MockModel._original = cls;
-    for (const name of Object.getOwnPropertyNames(cls)) {
-        if (name !== 'length' && name !== 'prototype' && name !== 'name') {
-            MockModel[name] = cls[name];
-        }
-    }
-    MockModel.tableName = opts?.tableName || cls.name || `Model${++autoTableNameId}`;
+    copyStaticMembersFromClassChain(MockModel, cls);
+    MockModel.tableName = tableName;
     if (MockModel.tableName in modelRegistry) {
         if (!opts?.override) {
             throw new DatabaseError(`Model with table name '${MockModel.tableName}' already registered`, 'INIT_ERROR');
@@ -111,25 +408,32 @@ export function defineModel(cls, opts) {
             }
         }
     }
-    if (opts?.pk) {
-        new PrimaryIndex(MockModel, Array.isArray(opts.pk) ? opts.pk : [opts.pk]);
-    }
-    else {
-        new PrimaryIndex(MockModel, ['id']);
+    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);
     }
-    const normalizeSpec = (spec) => typeof spec === 'string' ? [spec] : spec;
+    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[name] = new UniqueIndex(MockModel, normalizeSpec(spec));
+            MockModel._secondaries[name] = new UniqueIndex(tableName, normalizeSpec(spec), loadPrimary, queueInitialization);
         }
     }
     if (opts?.index) {
         for (const [name, spec] of Object.entries(opts.index)) {
-            MockModel[name] = new SecondaryIndex(MockModel, normalizeSpec(spec));
+            MockModel._secondaries[name] = new SecondaryIndex(tableName, normalizeSpec(spec), loadPrimary, queueInitialization);
         }
     }
     modelRegistry[MockModel.tableName] = MockModel;
-    scheduleInit();
+    pendingModelInits.add(MockModel);
     return MockModel;
 }
 /**
@@ -163,42 +467,27 @@ export function defineModel(cls, opts) {
  *
  * - **`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
- * const User = E.defineModel(class {
+ * const User = E.defineModel("User", class {
  *   id = E.field(E.identifier);
  *   name = E.field(E.string);
  *   email = E.field(E.string);
  * }, {
  *   pk: "id",
- *   unique: { byEmail: "email" },
+ *   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, defineModel replaces an existing model with the same tableName. */
-    static override;
-    /** Field configuration metadata. */
-    static fields;
-    // Alias statics that delegate to _primary, used by migrate.ts
-    static get _indexId() { return this._primary?._indexId; }
-    static get _currentVersion() { return this._primary._currentVersion; }
-    static get _pkFieldTypes() { return this._primary._fieldTypes; }
-    static _loadVersionInfo(txnId, version) { return this._primary._loadVersionInfo(txnId, version); }
-    static _writePrimary(txn, pk, data) { this._primary._write(txn, pk, data); }
+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
@@ -208,27 +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 = {}) {
-        throw new DatabaseError("Use defineModel() to create model classes", 'INIT_ERROR');
-    }
-    static _resetIndexes() {
-        this._primary._indexId = undefined;
-        this._primary._versions.clear();
-        for (const sec of this._secondaries || [])
-            sec._indexId = undefined;
-    }
-    static async _loadCreateIndexes() {
-        await this._primary._delayedInit();
-        for (const sec of this._secondaries || [])
-            await sec._delayedInit();
-        await this._primary._initVersioning();
-    }
     _setLoadedField(fieldName, value) {
         const oldValues = this._oldValues;
         if (oldValues.hasOwnProperty(fieldName))
@@ -243,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._serializeKey(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;
@@ -257,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.
@@ -268,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
@@ -291,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";
@@ -303,7 +592,8 @@ export class Model {
         // the whole object just to see if something changed.
         // Add old values of changed fields to 'changed'.
         const changed = {};
-        const fields = this.constructor.fields;
+        const cls = this.constructor;
+        const fields = cls.fields;
         for (const fieldName in oldValues) {
             const oldValue = oldValues[fieldName];
             const newValue = this[fieldName];
@@ -314,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");
             }
@@ -324,9 +614,9 @@ 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 || []) {
+        for (const index of Object.values(cls._secondaries || {})) {
             index._update(txn, pk, this, oldValues);
         }
         return changed;
@@ -344,53 +634,14 @@ export class Model {
      * ```
      */
     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;
     }
-    static get(...args) {
-        return this._primary.get(...args);
-    }
-    static getLazy(...args) {
-        return this._primary.getLazy(...args);
-    }
-    static find(opts) {
-        return this._primary.find(opts);
-    }
-    static batchProcess(opts, callback) {
-        return this._primary.batchProcess(opts, callback);
-    }
-    /**
-     * 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.
      *
@@ -404,12 +655,12 @@ export class Model {
      */
     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
@@ -423,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);
@@ -452,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";
             }
@@ -460,12 +712,49 @@ export class Model {
         return "loaded";
     }
     toString() {
-        const primary = this.constructor._primary;
-        const pk = primary._keyToArray(this._primaryKey || primary._serializeKey(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