edinburgh 0.4.5 → 0.5.0

package/src/migrate.ts

@@ -2,7 +2,6 @@ import * as lowlevel from "olmdb/lowlevel";
 import DataPack from "./datapack.js";
 import { modelRegistry, currentTxn, Transaction } from "./models.js";
 import { dbDel, toBuffer, bytesEqual } from "./utils.js";
-import { PrimaryIndex } from "./indexes.js";
 import { deserializeType, TypeWrapper } from "./types.js";
 import { transact } from "./edinburgh.js";
 
@@ -118,13 +117,12 @@ export async function runMigration(options: MigrationOptions = {}): Promise<Migr
 
     // Build maps of known index IDs
     const knownIndexIds = new Set<number>();
-    const primaryByIndexId = new Map<number, { model: typeof modelRegistry[string], primary: PrimaryIndex<any, any> }>();
+    const modelByPkIndexId = new Map<number, typeof modelRegistry[string]>();
 
     for (const model of Object.values(modelRegistry)) {
         if (options.tables && !options.tables.includes(model.tableName)) continue;
-        const primary = model._primary;
-        knownIndexIds.add(primary._indexId!);
-        primaryByIndexId.set(primary._indexId!, { model, primary });
+        knownIndexIds.add(model._indexId!);
+        modelByPkIndexId.set(model._indexId!, model);
         for (const sec of model._secondaries || []) {
             knownIndexIds.add(sec._indexId!);
         }
@@ -155,7 +153,7 @@ export async function runMigration(options: MigrationOptions = {}): Promise<Migr
 
     // Phase 1: Populate secondary indexes and/or rewrite row data
     if (populateSecondaries || rewriteData) {
-        for (const [indexId, { model, primary }] of primaryByIndexId) {
+        for (const [indexId, model] of modelByPkIndexId) {
             let secondaryCount = 0;
             let rewrittenCount = 0;
             const migrateFn = (model as any).migrate as ((record: Record<string, any>) => void) | undefined;
@@ -164,15 +162,15 @@ export async function runMigration(options: MigrationOptions = {}): Promise<Migr
             await forEachRow(indexId, (txn, keyBuf, valueBuf) => {
                 const valuePack = new DataPack(valueBuf);
                 const version = valuePack.readNumber();
-                if (version === primary._currentVersion) return; // Already current
+                if (version === model._currentVersion) return; // Already current
 
-                const versionInfo = primary._loadVersionInfo(txn.id, version);
+                const versionInfo = model._loadVersionInfo(txn.id, version);
 
                 // Deserialize pre-migrate values from key + old-format value
                 const record: Record<string, any> = {};
                 const keyPack = new DataPack(keyBuf);
                 keyPack.readNumber(); // skip indexId
-                for (const [name, type] of primary._fieldTypes.entries()) {
+                for (const [name, type] of model._pkFieldTypes.entries()) {
                     record[name] = type.deserialize(keyPack);
                 }
                 for (const [name, type] of versionInfo.nonKeyFields.entries()) {
@@ -191,33 +189,14 @@ export async function runMigration(options: MigrationOptions = {}): Promise<Migr
                             sec._write(txn, keyBuf, record as any);
                             secondaryCount++;
                         } else if (preMigrate) {
-                            if (sec._computeFn) {
-                                // Computed indexes: compare serialized keys to avoid unnecessary re-indexing
-                                const oldKeyBytes = sec._serializeKeyFields(preMigrate).toUint8Array();
-                                const newKeyBytes = sec._serializeKeyFields(record).toUint8Array();
-                                if (!bytesEqual(oldKeyBytes, newKeyBytes)) {
-                                    sec._delete(txn, keyBuf, preMigrate as any);
-                                    sec._write(txn, keyBuf, record as any);
-                                    secondaryCount++;
-                                }
-                            } else {
-                                // Existing secondary, update if migrate changed any of its fields
-                                for (const [field, type] of sec._fieldTypes.entries()) {
-                                    if (!type.equals(preMigrate[field], record[field])) {
-                                        sec._delete(txn, keyBuf, preMigrate as any);
-                                        sec._write(txn, keyBuf, record as any);
-                                        secondaryCount++;
-                                        break;
-                                    }
-                                }
-                            }
+                            if (sec._update(txn, keyBuf, record, preMigrate)) secondaryCount++;
                         }
                     }
                 }
 
                 // Rewrite primary row data to current version
                 if (rewriteData) {
-                    primary._write(txn, keyBuf, record);
+                    model._writePrimary(txn, keyBuf, record);
                     rewrittenCount++;
                 }
             });

package/src/models.ts

@@ -28,8 +28,8 @@ export interface Transaction {
     instances: Set<Model<unknown>>;
     instancesByPk: Map<number, Model<unknown>>;
 }
-import { BaseIndex as BaseIndex, PrimaryIndex, IndexRangeIterator } from "./indexes.js";
-import { addErrorPath, logLevel, assert, dbGet, hashBytes, bytesEqual } from "./utils.js";
+import { BaseIndex, NonPrimaryIndex, PrimaryIndex, IndexRangeIterator, UniqueIndex, SecondaryIndex, FindOptions } from "./indexes.js";
+import { addErrorPath, logLevel, assert, dbGet, hashBytes } from "./utils.js";
 
 /**
  * Configuration interface for model fields.
@@ -58,10 +58,10 @@ export interface FieldConfig<T> {
  * 
  * @example
  * ```typescript
- * class User extends E.Model<User> {
+ * const User = E.defineModel(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<T>(type: TypeWrapper<T>, options: Partial<FieldConfig<T>> = {}): T {
@@ -82,77 +82,161 @@ function isObjectEmpty(obj: object) {
 
 export type Change = Record<any, any> | "created" | "deleted";
 
+let autoTableNameId = 0;
+
+type FieldsOf<T> = T extends new () => infer I ? I : never;
+type ModelInstance<FIELDS> = FIELDS & Model<FIELDS>;
+
+type PKArgs<FIELDS, PK> =
+    PK extends readonly (keyof FIELDS & string)[]
+        ? { [I in keyof PK]: PK[I] extends keyof FIELDS ? FIELDS[PK[I]] : never }
+        : PK extends keyof FIELDS & string
+            ? [FIELDS[PK]]
+            : [string];
+
+type UniqueFor<SPEC> =
+    SPEC extends readonly string[] ? UniqueIndex<any, SPEC>
+    : SPEC extends string ? UniqueIndex<any, [SPEC]>
+    : SPEC extends (instance: any) => infer R
+        ? R extends (infer V)[] ? UniqueIndex<any, [], [V]>
+        : UniqueIndex<any, [], [R]>
+    : never;
+
+type SecondaryFor<SPEC> =
+    SPEC extends readonly string[] ? SecondaryIndex<any, SPEC>
+    : SPEC extends string ? SecondaryIndex<any, [SPEC]>
+    : SPEC extends (instance: any) => infer R
+        ? R extends (infer V)[] ? SecondaryIndex<any, [], [V]>
+        : SecondaryIndex<any, [], [R]>
+    : never;
+
+type RegisteredModel<FIELDS, PKA extends readonly any[], UNIQUE, INDEX> = {
+    new (initial?: Partial<FIELDS>): ModelInstance<FIELDS>;
+    tableName: string;
+    fields: Record<string | symbol | number, FieldConfig<unknown>>;
+    get(...args: PKA): ModelInstance<FIELDS> | undefined;
+    getLazy(...args: PKA): ModelInstance<FIELDS>;
+    find(opts: FindOptions<PKA, 'first'>): ModelInstance<FIELDS> | undefined;
+    find(opts: FindOptions<PKA, 'single'>): ModelInstance<FIELDS>;
+    find(opts?: FindOptions<PKA>): IndexRangeIterator<any>;
+    batchProcess(opts?: FindOptions<PKA> & { limitSeconds?: number; limitRows?: number }, callback?: (row: ModelInstance<FIELDS>) => any): Promise<void>;
+    replaceInto(obj: Partial<FIELDS>): ModelInstance<FIELDS>;
+} &
+    { [K in keyof UNIQUE]: UniqueFor<UNIQUE[K]> } &
+    { [K in keyof INDEX]: SecondaryFor<INDEX[K]> };
+
 /**
  * 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.
- * 
- * @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);
- * }
- * ```
+ *
+ * Converts a plain class into a fully-featured model with database persistence,
+ * typed fields, primary key access, and optional secondary and unique indexes.
+ *
+ * @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.tableName - Explicit database table name.
+ * @param opts.override - Replace a previous model with the same table name.
+ * @returns The enhanced model constructor.
  */
-export function registerModel<T extends typeof Model<unknown>>(MyModel: T): T {
-    const MockModel = getMockModel(MyModel);
+export function defineModel<
+    T extends new () => any,
+    const PK extends (keyof FieldsOf<T> & string) | readonly (keyof FieldsOf<T> & string)[],
+    const UNIQUE extends Record<string, (keyof FieldsOf<T> & string) | readonly (keyof FieldsOf<T> & string)[] | ((instance: any) => any)>,
+    const INDEX extends Record<string, (keyof FieldsOf<T> & string) | readonly (keyof FieldsOf<T> & string)[] | ((instance: any) => any)>,
+>(
+    cls: T,
+    opts?: { pk?: PK, unique?: UNIQUE, index?: INDEX, tableName?: string, override?: boolean }
+): RegisteredModel<FieldsOf<T>, PKArgs<FieldsOf<T>, PK>, UNIQUE, INDEX>;
+
+export function defineModel(cls: any, opts?: any): any {
+    Object.setPrototypeOf(cls.prototype, Model.prototype);
+
+    const MockModel = function(this: any, initial?: Record<string, any>, txn: Transaction = currentTxn()) {
+        this._txn = txn;
+        txn.instances.add(this);
+        if (initial) Object.assign(this, initial);
+    } as any;
 
-    // Copy own static methods/properties
-    for(const name of Object.getOwnPropertyNames(MyModel)) {
-        if (name !== 'length' && name !== 'prototype' && name !== 'name' && name !== 'mock' && name !== 'override') {
-            (MockModel as any)[name] = (MyModel as any)[name];
+    cls.prototype.constructor = MockModel;
+    Object.setPrototypeOf(MockModel, Model);
+    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 ||= MyModel.name;
 
-    // Register the constructor by name
+    MockModel.tableName = opts?.tableName || cls.name || `Model${++autoTableNameId}`;
+
     if (MockModel.tableName in modelRegistry) {
-        if (!(MyModel as any).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<T extends typeof Model<unknown>>(OrgModel: T): T {
-    const AnyOrgModel = OrgModel as any;
-    if (AnyOrgModel._isMock) return OrgModel;
-    if (AnyOrgModel._mock) return AnyOrgModel._mock;
+    const instance = new cls();
+    if (!opts?.pk && !instance.id) {
+        instance.id = { type: identifier };
+    }
 
-    const MockModel = function(this: any, initial?: Record<string,any> | undefined, txn: Transaction = 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);
+    MockModel.fields = {};
+    for (const key in instance) {
+        const value = instance[key] as FieldConfig<unknown>;
+        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: any) {
+                        Object.defineProperty(this, key, {
+                            value: val,
+                            configurable: true,
+                            writable: true,
+                            enumerable: true,
+                        });
+                    },
+                    configurable: true,
+                });
+            } else if (def !== undefined) {
+                MockModel.prototype[key] = def;
+            }
         }
-    } as any as T;
+    }
 
-    // We want .constructor to point at our fake constructor function.
-    OrgModel.prototype.constructor = MockModel as any;
+    if (opts?.pk) {
+        new PrimaryIndex(MockModel, Array.isArray(opts.pk) ? opts.pk : [opts.pk]);
+    } else {
+        new PrimaryIndex(MockModel, ['id']);
+    }
+
+    const normalizeSpec = (spec: any) => typeof spec === 'string' ? [spec] : spec;
+
+    if (opts?.unique) {
+        for (const [name, spec] of Object.entries<any>(opts.unique)) {
+            MockModel[name] = new UniqueIndex(MockModel, normalizeSpec(spec));
+        }
+    }
+    if (opts?.index) {
+        for (const [name, spec] of Object.entries<any>(opts.index)) {
+            MockModel[name] = new SecondaryIndex(MockModel, normalizeSpec(spec));
+        }
+    }
 
-    // Copy the prototype chain for the constructor as well as for instantiated objects
-    Object.setPrototypeOf(MockModel, Object.getPrototypeOf(OrgModel));
-    MockModel.prototype = OrgModel.prototype;
-    (MockModel as any)._isMock = true;
-    (MockModel as any)._original = OrgModel;
-    AnyOrgModel._mock = MockModel;
+    modelRegistry[MockModel.tableName] = MockModel;
     scheduleInit();
     return MockModel;
 }
 
-// Model base class and related symbols/state
-const INIT_INSTANCE_SYMBOL = Symbol();
-
 /**
  * Model interface that ensures proper typing for the constructor property.
  * @template SUB - The concrete model subclass.
@@ -165,8 +249,8 @@ export interface Model<SUB> {
  * 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
  *
@@ -202,16 +286,14 @@ export interface Model<SUB> {
  * 
  * @example
  * ```typescript
- * ⁣@E.registerModel
- * class User extends E.Model<User> {
- *   static pk = E.primary(User, "id");
- *   
+ * const User = E.defineModel(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: { byEmail: "email" },
+ * });
  * ```
  */
 
@@ -220,17 +302,24 @@ export abstract class Model<SUB> {
     static _primary: PrimaryIndex<any, any>;
 
     /** @internal All non-primary indexes for this model. */
-    static _secondaries?: BaseIndex<any, readonly (keyof any & string)[]>[];
+    static _secondaries?: NonPrimaryIndex<any, readonly (keyof any & string)[]>[];
 
     /** The database table name (defaults to class name). */
     static tableName: string;
 
-    /** When true, registerModel replaces an existing model with the same tableName. */
+    /** When true, defineModel replaces an existing model with the same tableName. */
     static override?: boolean;
 
     /** Field configuration metadata. */
     static fields: Record<string | symbol | number, FieldConfig<unknown>>;
 
+    // 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: number, version: number) { return this._primary._loadVersionInfo(txnId, version); }
+    static _writePrimary(txn: Transaction, pk: Uint8Array, data: Record<string, any>) { this._primary._write(txn, pk, data as any); }
+
     /**
      * Optional migration function called when deserializing rows written with an older schema version.
      * Receives a plain record with all fields (primary key fields + value fields) and should mutate it
@@ -247,9 +336,7 @@ export abstract class Model<SUB> {
      *
      * @example
      * ```typescript
-     * ⁣@E.registerModel
-     * class User extends E.Model<User> {
-     *   static pk = E.primary(User, "id");
+     * const User = E.defineModel(class {
      *   id = E.field(E.identifier);
      *   name = E.field(E.string);
      *   role = E.field(E.string);  // new field
@@ -257,7 +344,7 @@ export abstract class Model<SUB> {
      *   static migrate(record: Record<string, any>) {
      *     record.role ??= "user";  // default for rows that predate the 'role' field
      *   }
-     * }
+     * }, { pk: "id" });
      * ```
      */
     static migrate?(record: Record<string, any>): void;
@@ -280,10 +367,7 @@ export abstract class Model<SUB> {
     _txn!: Transaction;
 
     constructor(initial: Partial<Omit<SUB, "constructor">> = {}) {
-        // 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 as any === INIT_INSTANCE_SYMBOL) return;
-        throw new DatabaseError("The model needs a @E.registerModel decorator", 'INIT_ERROR');
+        throw new DatabaseError("Use defineModel() to create model classes", 'INIT_ERROR');
     }
 
     /**
@@ -298,9 +382,7 @@ export abstract class Model<SUB> {
      *
      * @example
      * ```typescript
-     * ⁣@E.registerModel
-     * class Post extends E.Model<Post> {
-     *   static pk = E.primary(Post, "id");
+     * const Post = E.defineModel(class {
      *   id = E.field(E.identifier);
      *   title = E.field(E.string);
      *   slug = E.field(E.string);
@@ -308,79 +390,21 @@ export abstract class Model<SUB> {
      *   preCommit() {
      *     this.slug = this.title.toLowerCase().replace(/\s+/g, "-");
      *   }
-     * }
+     * }, { pk: "id" });
      * ```
      */
     preCommit?(): void;
 
-    static async _delayedInit(cleared?: boolean): Promise<void> {
-        const MockModel = getMockModel(this);
-
-        if (cleared) {
-            MockModel._primary._indexId = undefined;
-            MockModel._primary._versions.clear();
-            for (const sec of MockModel._secondaries || []) sec._indexId = undefined;
-        }
-
-        if (!MockModel.fields) {
-            // First-time init: gather field configs from a temporary instance of the original class.
-            const OrgModel = (MockModel as any)._original || this;
-            const instance = new (OrgModel as any)(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] as FieldConfig<unknown>;
-                // 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: any) {
-                                Object.defineProperty(this, key, {
-                                    value: val,
-                                    configurable: true,
-                                    writable: true,
-                                    enumerable: true,
-                                })
-                            },
-                            configurable: true,    
-                        });
-                    } else if (def !== undefined) {
-                        (MockModel.prototype as any)[key] = def;
-                    }
-                }
-            }
-
-            if (logLevel >= 1) {
-                console.log(`[edinburgh] Registered model ${MockModel.tableName} with fields: ${Object.keys(MockModel.fields).join(' ')}`);
-            }
-        }
+    static _resetIndexes(): void {
+        this._primary._indexId = undefined;
+        this._primary._versions.clear();
+        for (const sec of this._secondaries || []) sec._indexId = undefined;
+    }
 
-        // 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();
+    static async _loadCreateIndexes(): Promise<void> {
+        await this._primary._delayedInit();
+        for (const sec of this._secondaries || []) await sec._delayedInit();
+        await this._primary._initVersioning();
     }
 
     _setLoadedField(fieldName: string, value: any) {
@@ -403,7 +427,7 @@ export abstract class Model<SUB> {
     getPrimaryKey(): Uint8Array {
         let key = this._primaryKey;
         if (key === undefined) {
-            key = this.constructor._primary!._serializeKeyFields(this).toUint8Array();
+            key = this.constructor._primary!._serializeKey(this).toUint8Array();
             this._setPrimaryKey(key);
         }
         return key;
@@ -468,8 +492,8 @@ export abstract class Model<SUB> {
         // the whole object just to see if something changed.
 
         // Add old values of changed fields to 'changed'.
+        const changed: Record<string, any> = {};
         const fields = this.constructor.fields;
-        let changed : Record<any, any> = {};
         for(const fieldName in oldValues) {
             const oldValue = oldValues[fieldName];
             const newValue = this[fieldName as keyof Model<SUB>];
@@ -498,23 +522,7 @@ export abstract class Model<SUB> {
 
         // 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 as any).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;
-                    }
-                }
-            }
+            index._update(txn, pk, this, oldValues);
         }
         return changed;
     }
@@ -526,7 +534,7 @@ export abstract class Model<SUB> {
      * 
      * @example
      * ```typescript
-     * const user = User.load("user123");
+     * const user = User.get("user123");
      * user.name = "New Name";
      * user.preventPersist(); // Changes won't be saved
      * ```
@@ -538,16 +546,22 @@ export abstract class Model<SUB> {
         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<T extends typeof Model<unknown>>(this: T, opts?: {reverse?: boolean}): IndexRangeIterator<T> {
+    static get(...args: any[]): any {
+        return this._primary!.get(...args);
+    }
+
+    static getLazy(...args: any[]): any {
+        return this._primary!.getLazy(...args);
+    }
+
+    static find(opts?: any): any {
         return this._primary!.find(opts);
     }
 
+    static batchProcess(opts: any, callback?: any): any {
+        return this._primary!.batchProcess(opts, callback);
+    }
+
     /**
      * Load an existing instance by primary key and update it, or create a new one.
      *
@@ -558,7 +572,7 @@ export abstract class Model<SUB> {
      * @param obj - Partial model data that **must** include every primary key field.
      * @returns The loaded-and-updated or newly created instance.
      */
-    static replaceInto<T extends typeof Model<any>>(this: T, obj: Partial<Omit<InstanceType<T>, "constructor">>): InstanceType<T> {
+    static replaceInto<T extends typeof Model<any>>(this: T, obj: Partial<Record<string, any>>): InstanceType<T> {
         const pk = this._primary!;
         const keyArgs = [];
         for (const fieldName of pk._fieldTypes.keys()) {
@@ -587,7 +601,7 @@ export abstract class Model<SUB> {
      * 
      * @example
      * ```typescript
-     * const user = User.load("user123");
+     * const user = User.get("user123");
      * user.delete(); // Removes from database
      * ```
      */
@@ -651,7 +665,7 @@ export abstract class Model<SUB> {
 
     toString(): string {
         const primary = this.constructor._primary;
-        const pk = primary._keyToArray(this._primaryKey || primary._serializeKeyFields(this).toUint8Array(false));
+        const pk = primary._keyToArray(this._primaryKey || primary._serializeKey(this).toUint8Array(false));
         return `{Model:${this.constructor.tableName} ${this.getState()} ${pk}}`;
     }