edinburgh 0.4.6 → 0.5.0

package/src/edinburgh.ts

@@ -9,8 +9,9 @@ export function scheduleInit() { initNeeded = true; }
 // Re-export public API from models
 export {
     Model,
-    registerModel,
+    defineModel,
     field,
+    currentTxn,
 } from "./models.js";
 
 import type { Transaction, Change, Model } from "./models.js";
@@ -37,13 +38,10 @@ export {
 
 // Re-export public API from indexes
 export {
-    index,
-    primary,
-    unique,
     dump,
 } from "./indexes.js";
 
-export { BaseIndex, UniqueIndex, PrimaryIndex, SecondaryIndex } from './indexes.js';
+export { BaseIndex, NonPrimaryIndex, UniqueIndex, SecondaryIndex } from './indexes.js';
 
 export { type Change } from './models.js';
 export type { Transaction } from './models.js';
@@ -99,7 +97,7 @@ const STALE_INSTANCE_DESCRIPTOR = {
 * @example
 * ```typescript
 * const paid = await E.transact(() => {
-*   const user = User.pk.get("john_doe");
+*   const user = User.get("john_doe");
 *   if (user.credits > 0) {
 *     user.credits--;
 *     return true;
@@ -110,7 +108,7 @@ const STALE_INSTANCE_DESCRIPTOR = {
 * ```typescript
 * // Transaction with automatic retry on conflicts
 * await E.transact(() => {
-*   const counter = Counter.pk.get("global") || new Counter({id: "global", value: 0});
+*   const counter = Counter.get("global") || new Counter({id: "global", value: 0});
 *   counter.value++;
 * });
 * ```
@@ -126,7 +124,6 @@ export async function transact<T>(fn: () => T): Promise<T> {
                 olmdbReady = true;
                 initNeeded = false;
                 for (const model of Object.values(modelRegistry)) {
-                    model.initFields();
                     await model._loadCreateIndexes();
                 }
             })();
@@ -248,7 +245,7 @@ export async function deleteEverything(): Promise<void> {
     // Re-init indexes since metadata was deleted
     for (const model of Object.values(modelRegistry)) {
         if (!model.fields) continue;
-        model.initFields(true);
+        model._resetIndexes();
         await model._loadCreateIndexes();
     }
 }

package/src/indexes.ts

@@ -1,7 +1,7 @@
 import * as lowlevel from "olmdb/lowlevel";
 import { DatabaseError } from "olmdb/lowlevel";
 import DataPack from "./datapack.js";
-import { FieldConfig, getMockModel, Model, Transaction, currentTxn } from "./models.js";
+import { FieldConfig, Model, Transaction, currentTxn } from "./models.js";
 import { scheduleInit, transact } from "./edinburgh.js";
 import { assert, logLevel, dbGet, dbPut, dbDel, hashBytes, hashFunction, bytesEqual, toBuffer } from "./utils.js";
 import { deserializeType, serializeType, TypeWrapper } from "./types.js";
@@ -18,7 +18,7 @@ const VERSION_INFO_PREFIX = -3;
 const MAX_INDEX_ID_BUFFER = new DataPack().write(MAX_INDEX_ID_PREFIX).toUint8Array();
 
 /** Cached information about a specific version of a primary index's value format. */
-interface VersionInfo {
+export interface VersionInfo {
     migrateHash: number;
     /** Non-key field names → TypeWrappers for deserialization of this version's data. */
     nonKeyFields: Map<string, TypeWrapper<any>>;
@@ -41,6 +41,10 @@ export class IndexRangeIterator<M extends typeof Model> extends Iterator<Instanc
         super();
     }
 
+    // This is also in Iterator<InstanceType<M>>, but we'll repeat it here for deps that
+    // don't have ESNext.Iterator in their TypeScript lib set.
+    [Symbol.iterator](): this { return this; }
+
     next(): IteratorResult<InstanceType<M>> {
         if (this.iteratorId < 0) return { done: true, value: undefined };
         const raw = lowlevel.readIterator(this.iteratorId);
@@ -71,7 +75,7 @@ export class IndexRangeIterator<M extends typeof Model> extends Iterator<Instanc
 
 type ArrayOrOnlyItem<ARG_TYPES extends readonly any[]> = ARG_TYPES extends readonly [infer A] ? (A | Partial<ARG_TYPES>) : Partial<ARG_TYPES>;
 
-type FindOptions<ARG_TYPES extends readonly any[]> = (
+export type FindOptions<ARG_TYPES extends readonly any[], FETCH extends 'first' | 'single' | undefined = undefined> = (
     (
         {is: ArrayOrOnlyItem<ARG_TYPES>;} // Shortcut for setting `from` and `to` to the same value
     |
@@ -96,6 +100,7 @@ type FindOptions<ARG_TYPES extends readonly any[]> = (
     {
         reverse?: boolean;
     }
+    & (FETCH extends undefined ? { fetch?: undefined } : { fetch: FETCH })
 );
 
 
@@ -111,7 +116,6 @@ export abstract class BaseIndex<M extends typeof Model, const F extends readonly
     public _MyModel: M;
     public _fieldTypes: Map<keyof InstanceType<M> & string, TypeWrapper<any>> = new Map();
     public _fieldCount!: number;
-    _resetIndexFieldDescriptors: Record<string | symbol | number, PropertyDescriptor> = {};
     _computeFn?: (data: any) => any[];
     
     /**
@@ -120,7 +124,7 @@ export abstract class BaseIndex<M extends typeof Model, const F extends readonly
      * @param _fieldNames - Array of field names that make up this index.
      */
     constructor(MyModel: M, public _fieldNames: F) {
-        this._MyModel = getMockModel(MyModel);
+        this._MyModel = MyModel;
     }
 
     async _delayedInit() {
@@ -143,14 +147,6 @@ export abstract class BaseIndex<M extends typeof Model, const F extends readonly
             this._signature = this._getTypeName() + ' ' +
                 Array.from(this._fieldTypes.entries()).map(([n, t]) => n + ':' + t).join(' ');
         }
-
-        for(const fieldName of this._fieldTypes.keys()) {
-            this._resetIndexFieldDescriptors[fieldName] = {
-                writable: true,
-                configurable: true,
-                enumerable: true
-            };
-        }
     }
 
     _indexId?: number;
@@ -193,32 +189,6 @@ export abstract class BaseIndex<M extends typeof Model, const F extends readonly
      */
     abstract _pairToInstance(txn: Transaction, keyBuffer: ArrayBuffer, valueBuffer: ArrayBuffer): InstanceType<M>;
 
-    _hasNullIndexValues(data: Record<string, any>) {
-        assert(!this._computeFn);
-        for(const fieldName of this._fieldTypes.keys()) {
-            if (data[fieldName] == null) return true;
-        }
-        return false;
-    }
-
-    // Must return the exact key that will be used to write to the K/V store
-    abstract _serializeKey(primaryKey: Uint8Array, data: Record<string, any>): Uint8Array;
-
-    // Returns the indexId + serialized key fields. Used in some _serializeKey implementations
-    // and for calculating _primaryKey.
-    _serializeKeyFields(data: Record<string, any>): DataPack {
-        const bytes = new DataPack();
-        bytes.write(this._indexId!);
-        if (this._computeFn) {
-            for (const v of this._computeFn(data)) bytes.write(v);
-        } else {
-            for(const [fieldName, fieldType] of this._fieldTypes.entries()) {
-                fieldType.serialize(data[fieldName], bytes);
-            }
-        }
-        return bytes;
-    }
-
     /**
      * Retrieve (or create) a stable index ID from the DB, with retry on transaction races.
      * Sets `this._indexId` on success.
@@ -273,9 +243,6 @@ export abstract class BaseIndex<M extends typeof Model, const F extends readonly
     }
 
 
-    abstract _delete(txn: Transaction, primaryKey: Uint8Array, model: InstanceType<M>): void;
-    abstract _write(txn: Transaction, primaryKey: Uint8Array, model: InstanceType<M>): void;
-
     /**
      * Find model instances using flexible range query options.
      * 
@@ -324,7 +291,7 @@ export abstract class BaseIndex<M extends typeof Model, const F extends readonly
      * }
      * 
      * // Multi-field index prefix matching
-     * for (const item of CompositeModel.pk.find({from: ["electronics", "phones"]})) {
+     * for (const item of CompositeModel.find({from: ["electronics", "phones"]})) {
      *   console.log(item.name); // All electronics/phones items
      * }
      * 
@@ -360,12 +327,19 @@ export abstract class BaseIndex<M extends typeof Model, const F extends readonly
         return [startKey, endKey];
     }
 
-    public find(opts: FindOptions<ARGS> = {}): IndexRangeIterator<M> {
+    public find(opts?: FindOptions<ARGS, 'first'>): InstanceType<M> | undefined;
+    public find(opts: FindOptions<ARGS, 'single'>): InstanceType<M>;
+    public find(opts?: FindOptions<ARGS>): IndexRangeIterator<M>;
+    public find(opts: any = {}): IndexRangeIterator<M> | InstanceType<M> | undefined {
         const txn = currentTxn();
         const indexId = this._indexId!;
 
         const bounds = this._computeKeyBounds(opts);
-        if (!bounds) return new IndexRangeIterator(txn, -1, indexId, this);
+        if (!bounds) {
+            if (opts.fetch === 'single') throw new DatabaseError('Expected exactly one result, got none', 'NOT_FOUND');
+            if (opts.fetch === 'first') return undefined;
+            return new IndexRangeIterator(txn, -1, indexId, this);
+        }
         const [startKey, endKey] = bounds;
 
         // For reverse scans, swap start/end keys since OLMDB expects it
@@ -384,7 +358,15 @@ export abstract class BaseIndex<M extends typeof Model, const F extends readonly
             opts.reverse || false,
         );
         
-        return new IndexRangeIterator(txn, iteratorId, indexId, this);
+        const iter = new IndexRangeIterator(txn, iteratorId, indexId, this);
+        if (opts.fetch === 'first') return iter.fetch();
+        if (opts.fetch === 'single') {
+            const first = iter.fetch();
+            if (!first) throw new DatabaseError('Expected exactly one result, got none', 'NOT_FOUND');
+            if (iter.fetch() !== undefined) throw new DatabaseError('Expected exactly one result, got multiple', 'NOT_UNIQUE');
+            return first;
+        }
+        return iter;
     }
 
     /**
@@ -624,7 +606,7 @@ export class PrimaryIndex<M extends typeof Model, const F extends readonly (keyo
      * 
      * @example
      * ```typescript
-     * const user = User.pk.get("john_doe");
+     * const user = User.get("john_doe");
      * ```
      */
     get(...args: IndexArgTypes<M, F>): InstanceType<M> | undefined {
@@ -697,7 +679,7 @@ export class PrimaryIndex<M extends typeof Model, const F extends readonly (keyo
             }
         }
 
-        // Store the canonical primary key on the model, set the hash, and freeze the primary key fields.
+        // Store the primary key on the model, set the hash, and freeze the primary key fields.
         model._setPrimaryKey(key, keyHash);
 
         if (valueBuffer) {
@@ -716,8 +698,16 @@ export class PrimaryIndex<M extends typeof Model, const F extends readonly (keyo
         return model;
     }
 
-    _serializeKey(primaryKey: Uint8Array, _data: Record<string, any>): Uint8Array {
-        return primaryKey;
+    /**
+     * Serialize primary key bytes from field values: indexId + typed field values.
+     */
+    _serializeKey(data: Record<string, any>): DataPack {
+        const bytes = new DataPack();
+        bytes.write(this._indexId!);
+        for (const [fieldName, fieldType] of this._fieldTypes.entries()) {
+            fieldType.serialize(data[fieldName], bytes);
+        }
+        return bytes;
     }
 
     _lazyNow(model: InstanceType<M>) {
@@ -839,13 +829,15 @@ export class PrimaryIndex<M extends typeof Model, const F extends readonly (keyo
     }
 }
 
+// OLMDB does not support storing empty values, so we use a single byte value for secondary indexes.
+const SECONDARY_VALUE = new DataPack().write(undefined).toUint8Array();
+
 /**
- * Unique index that stores references to the primary key.
- * 
- * @template M - The model class this index belongs to.
- * @template F - The field names that make up this index.
+ * Abstract base for all non-primary indexes (unique and secondary).
+ * Provides shared key serialization, write/delete/update logic.
  */
-export class UniqueIndex<M extends typeof Model, const F extends readonly (keyof InstanceType<M> & string)[], ARGS extends readonly any[] = IndexArgTypes<M, F>> extends BaseIndex<M, F, ARGS> {
+export abstract class NonPrimaryIndex<M extends typeof Model, const F extends readonly (keyof InstanceType<M> & string)[], ARGS extends readonly any[] = IndexArgTypes<M, F>> extends BaseIndex<M, F, ARGS> {
+    _resetIndexFieldDescriptors: Record<string | symbol | number, PropertyDescriptor> = {};
 
     constructor(MyModel: M, fieldsOrFn: F | ((data: any) => any[])) {
         super(MyModel, typeof fieldsOrFn === 'function' ? [] as any : fieldsOrFn);
@@ -854,16 +846,104 @@ export class UniqueIndex<M extends typeof Model, const F extends readonly (keyof
         scheduleInit();
     }
 
+    async _delayedInit() {
+        await super._delayedInit();
+        for (const fieldName of this._fieldTypes.keys()) {
+            this._resetIndexFieldDescriptors[fieldName] = {
+                writable: true,
+                configurable: true,
+                enumerable: true
+            };
+        }
+    }
+
     /**
-     * Get a model instance by unique index key values.
-     * @param args - The unique index key values.
-     * @returns The model instance if found, undefined otherwise.
-     * 
-     * @example
-     * ```typescript
-     * const userByEmail = User.byEmail.get("john@example.com");
-     * ```
+     * Build DataPack key prefixes (indexId + field/computed values). Returns [] to skip indexing.
+     * SecondaryIndex appends the primary key to each pack before converting to Uint8Array.
+     */
+    _buildKeyPacks(data: Record<string, any>): DataPack[] {
+        if (this._computeFn) {
+            return this._computeFn(data).map((value: any) => {
+                const bytes = new DataPack();
+                bytes.write(this._indexId!);
+                bytes.write(value);
+                return bytes;
+            });
+        }
+        for (const fieldName of this._fieldTypes.keys()) {
+            if (data[fieldName] == null) return [];
+        }
+        const bytes = new DataPack();
+        bytes.write(this._indexId!);
+        for (const [fieldName, fieldType] of this._fieldTypes.entries()) {
+            fieldType.serialize(data[fieldName], bytes);
+        }
+        return [bytes];
+    }
+
+    /** Serialize all index keys. Default: key = indexId + fields. */
+    _serializeKeys(primaryKey: Uint8Array, data: Record<string, any>): Uint8Array[] {
+        return this._buildKeyPacks(data).map(p => p.toUint8Array());
+    }
+
+    /** Write a single pre-serialized key — subclasses define value and uniqueness check. */
+    abstract _writeKey(txn: Transaction, key: Uint8Array, primaryKey: Uint8Array): void;
+
+    _write(txn: Transaction, primaryKey: Uint8Array, model: InstanceType<M>): void {
+        for (const key of this._serializeKeys(primaryKey, model as any)) {
+            if (logLevel >= 2) console.log(`[edinburgh] Write ${this} key=${new DataPack(key)}`);
+            this._writeKey(txn, key, primaryKey);
+        }
+    }
+
+    _delete(txn: Transaction, primaryKey: Uint8Array, model: InstanceType<M>): void {
+        for (const key of this._serializeKeys(primaryKey, model as any)) {
+            if (logLevel >= 2) console.log(`[edinburgh] Delete ${this} key=${new DataPack(key)}`);
+            dbDel(txn.id, key);
+        }
+    }
+
+    /**
+     * Granular update: diff old vs new keys and only insert/delete what changed.
+     * For non-computed indexes, uses a fast path that checks which fields changed.
      */
+    _update(txn: Transaction, primaryKey: Uint8Array, newData: InstanceType<M>, oldData: Record<string, any>): number {
+        const oldKeys = this._serializeKeys(primaryKey, oldData);
+        const newKeys = this._serializeKeys(primaryKey, newData as any);
+
+        // Fast path: no changes and max 1 key
+        if (oldKeys.length === newKeys.length && (oldKeys.length === 0 || bytesEqual(oldKeys[0], newKeys[0]))) {
+            return 0;
+        }
+
+        const oldKeyMap = new Map<number, Uint8Array>();
+        for (const key of oldKeys) oldKeyMap.set(hashBytes(key), key);
+
+        let changes = 0;
+        for (const key of newKeys) {
+            const hash = hashBytes(key);
+            if (oldKeyMap.has(hash)) {
+                oldKeyMap.delete(hash);
+            } else {
+                if (logLevel >= 2) console.log(`[edinburgh] Write ${this} key=${new DataPack(key)}`);
+                this._writeKey(txn, key, primaryKey);
+                changes++;
+            }
+        }
+        for (const key of oldKeyMap.values()) {
+            if (logLevel >= 2) console.log(`[edinburgh] Delete ${this} key=${new DataPack(key)}`);
+            dbDel(txn.id, key);
+            changes++;
+        }
+        return changes;
+    }
+}
+
+/**
+ * Unique index that stores references to the primary key.
+ */
+export class UniqueIndex<M extends typeof Model, const F extends readonly (keyof InstanceType<M> & string)[], ARGS extends readonly any[] = IndexArgTypes<M, F>> extends NonPrimaryIndex<M, F, ARGS> {
+
     get(...args: ARGS): InstanceType<M> | undefined {
         const txn = currentTxn();
         let keyBuffer = this._argsToKeyBytes(args, false).toUint8Array();
@@ -880,65 +960,20 @@ export class UniqueIndex<M extends typeof Model, const F extends readonly (keyof
         return result;
     }
 
-    _serializeKey(primaryKey: Uint8Array, data: Record<string, any>): Uint8Array {
-        return this._serializeKeyFields(data).toUint8Array();
-    }
-
-    _delete(txn: Transaction, primaryKey: Uint8Array, data: Record<string, any>) {
-        if (this._computeFn) {
-            for (const value of this._computeFn(data)) {
-                const key = new DataPack().write(this._indexId!).write(value).toUint8Array();
-                if (logLevel >= 2) console.log(`[edinburgh] Delete ${this} fn-key=${key}`);
-                dbDel(txn.id, key);
-            }
-            return;
-        }
-        if (!this._hasNullIndexValues(data)) {
-            const key = this._serializeKey(primaryKey, data);
-            if (logLevel >= 2) {
-                console.log(`[edinburgh] Delete ${this} key=${key}`);
-            }
-            dbDel(txn.id, key);
-        }
-    }
-
-    _write(txn: Transaction, primaryKey: Uint8Array, data: Record<string, any>) {
-        if (this._computeFn) {
-            for (const value of this._computeFn(data)) {
-                const key = new DataPack().write(this._indexId!).write(value).toUint8Array();
-                if (logLevel >= 2) console.log(`[edinburgh] Write ${this} fn-key=${key} value=${new DataPack(primaryKey)}`);
-                if (dbGet(txn.id, key)) throw new DatabaseError(`Unique constraint violation for ${this} key ${key}`, 'UNIQUE_CONSTRAINT');
-                dbPut(txn.id, key, primaryKey);
-            }
-            return;
-        }
-        if (!this._hasNullIndexValues(data)) {
-            const key = this._serializeKey(primaryKey, data);
-            if (logLevel >= 2) {
-                console.log(`[edinburgh] Write ${this} key=${key} value=${new DataPack(primaryKey)}`);
-            }
-            if (dbGet(txn.id, key)) {
-                throw new DatabaseError(`Unique constraint violation for ${this} key ${key}`, 'UNIQUE_CONSTRAINT');
-            }
-            dbPut(txn.id, key, primaryKey);
-        }
+    _writeKey(txn: Transaction, key: Uint8Array, primaryKey: Uint8Array): void {
+        if (dbGet(txn.id, key)) throw new DatabaseError(`Unique constraint violation for ${this}`, 'UNIQUE_CONSTRAINT');
+        dbPut(txn.id, key, primaryKey);
     }
 
     _pairToInstance(txn: Transaction, keyBuffer: ArrayBuffer, valueBuffer: ArrayBuffer): InstanceType<M> {
-        // For unique indexes, the value contains the primary key
-
         const pk = this._MyModel._primary!;
         const model = pk._get(txn, new Uint8Array(valueBuffer), false);
 
-        if (!this._computeFn) {
+        if (this._fieldTypes.size > 0) {
             const keyPack = new DataPack(new Uint8Array(keyBuffer));
             keyPack.readNumber(); // discard index id
 
-            // _get will have created lazy-load getters for our indexed fields. Let's turn them back into
-            // regular properties:
             Object.defineProperties(model, this._resetIndexFieldDescriptors);
-
-            // Set the values for our indexed fields
             for(const [name, fieldType] of this._fieldTypes.entries()) {
                 model._setLoadedField(name, fieldType.deserialize(keyPack));
             }
@@ -952,50 +987,27 @@ export class UniqueIndex<M extends typeof Model, const F extends readonly (keyof
     }
 }
 
-// OLMDB does not support storing empty values, so we use a single byte value for secondary indexes.
-const SECONDARY_VALUE = new DataPack().write(undefined).toUint8Array(); // Single byte value for secondary indexes
-
 /**
  * Secondary index for non-unique lookups.
- * 
- * @template M - The model class this index belongs to.
- * @template F - The field names that make up this index.
  */
-export class SecondaryIndex<M extends typeof Model, const F extends readonly (keyof InstanceType<M> & string)[], ARGS extends readonly any[] = IndexArgTypes<M, F>> extends BaseIndex<M, F, ARGS> {
-
-    constructor(MyModel: M, fieldsOrFn: F | ((data: any) => any[])) {
-        super(MyModel, typeof fieldsOrFn === 'function' ? [] as any : fieldsOrFn);
-        if (typeof fieldsOrFn === 'function') this._computeFn = fieldsOrFn;
-        (this._MyModel._secondaries ||= []).push(this);
-        scheduleInit();
-    }
+export class SecondaryIndex<M extends typeof Model, const F extends readonly (keyof InstanceType<M> & string)[], ARGS extends readonly any[] = IndexArgTypes<M, F>> extends NonPrimaryIndex<M, F, ARGS> {
 
     _pairToInstance(txn: Transaction, keyBuffer: ArrayBuffer, _valueBuffer: ArrayBuffer): InstanceType<M> {
-        // For secondary indexes, the primary key is stored after the index fields in the key
-
         const keyPack = new DataPack(new Uint8Array(keyBuffer));
         keyPack.readNumber(); // discard index id
         
-        // Read the index fields (or skip computed value)
         const indexFields = new Map();
-        if (this._computeFn) {
-            keyPack.read(); // skip computed value
-        } else {
-            for(const [name, type] of this._fieldTypes.entries()) {
-                indexFields.set(name, type.deserialize(keyPack));
-            }
+        for (const [name, type] of this._fieldTypes.entries()) {
+            indexFields.set(name, type.deserialize(keyPack));
         }
+        if (this._computeFn) keyPack.read(); // skip computed value
 
         const primaryKey = keyPack.readUint8Array();
         const model = this._MyModel._primary!._get(txn, primaryKey, false);
 
         if (indexFields.size > 0) {
-            // _get will have created lazy-load getters for our indexed fields. Let's turn them back into
-            // regular properties:
             Object.defineProperties(model, this._resetIndexFieldDescriptors);
-
-            // Set the values for our indexed fields
-            for(const [name, value] of indexFields) {
+            for (const [name, value] of indexFields) {
                 model._setLoadedField(name, value);
             }
         }
@@ -1003,147 +1015,19 @@ export class SecondaryIndex<M extends typeof Model, const F extends readonly (ke
         return model;
     }
 
-    _serializeKey(primaryKey: Uint8Array, model: InstanceType<M>): Uint8Array {
-        // index id + index fields + primary key
-        const bytes = super._serializeKeyFields(model);
-        bytes.write(primaryKey);
-        return bytes.toUint8Array();
+    _serializeKeys(primaryKey: Uint8Array, data: Record<string, any>): Uint8Array[] {
+        return this._buildKeyPacks(data).map(p => { p.write(primaryKey); return p.toUint8Array(); });
     }
 
-    _write(txn: Transaction, primaryKey: Uint8Array, model: InstanceType<M>) {
-        if (this._computeFn) {
-            for (const value of this._computeFn(model)) {
-                const key = new DataPack().write(this._indexId!).write(value).write(primaryKey).toUint8Array();
-                if (logLevel >= 2) console.log(`[edinburgh] Write ${this} fn-key=${key}`);
-                dbPut(txn.id, key, SECONDARY_VALUE);
-            }
-            return;
-        }
-        if (this._hasNullIndexValues(model)) return;
-        const key = this._serializeKey(primaryKey, model);
-        if (logLevel >= 2) {
-            console.log(`[edinburgh] Write ${this} key=${key}`);
-        }
+    _writeKey(txn: Transaction, key: Uint8Array, _primaryKey: Uint8Array): void {
         dbPut(txn.id, key, SECONDARY_VALUE);
     }
 
-    _delete(txn: Transaction, primaryKey: Uint8Array, model: InstanceType<M>): void {
-        if (this._computeFn) {
-            for (const value of this._computeFn(model)) {
-                const key = new DataPack().write(this._indexId!).write(value).write(primaryKey).toUint8Array();
-                if (logLevel >= 2) console.log(`[edinburgh] Delete ${this} fn-key=${key}`);
-                dbDel(txn.id, key);
-            }
-            return;
-        }
-        if (this._hasNullIndexValues(model)) return;
-        const key = this._serializeKey(primaryKey, model);
-        if (logLevel >= 2) {
-            console.log(`[edinburgh] Delete ${this} key=${key}`);
-        }
-        dbDel(txn.id, key);
-    }
-
     _getTypeName(): string {
         return this._computeFn ? 'fn-secondary' : 'secondary';
     }
 }
 
-// Type alias for backward compatibility
-export type Index<M extends typeof Model, F extends readonly (keyof InstanceType<M> & string)[]> = 
-    PrimaryIndex<M, F> | UniqueIndex<M, F> | SecondaryIndex<M, F>;
-
-/**
- * Create a primary index on model fields.
- * @template M - The model class.
- * @template F - The field name (for single field index).
- * @template FS - The field names array (for composite index).
- * @param MyModel - The model class to create the index for.
- * @param field - Single field name for simple indexes.
- * @param fields - Array of field names for composite indexes.
- * @returns A new PrimaryIndex instance.
- * 
- * @example
- * ```typescript
- * class User extends E.Model<User> {
- *   static pk = E.primary(User, ["id"]);
- *   static pkSingle = E.primary(User, "id");
- * }
- * ```
- */
-export function primary<M extends typeof Model, const F extends (keyof InstanceType<M> & string)>(MyModel: M, field: F): PrimaryIndex<M, [F]>;
-export function primary<M extends typeof Model, const FS extends readonly (keyof InstanceType<M> & string)[]>(MyModel: M, fields: FS): PrimaryIndex<M, FS>;
-
-export function primary(MyModel: typeof Model, fields: any): PrimaryIndex<any, any> {
-    return new PrimaryIndex(MyModel, Array.isArray(fields) ? fields : [fields]);
-}
-
-/**
- * Create a unique index on model fields, or a computed unique index using a function.
- *
- * For field-based indexes, pass a field name or array of field names.
- * For computed indexes, pass a function that takes a model instance and returns an array of
- * index keys. Return `[]` to skip indexing for that instance. Each array element creates a
- * separate index entry, enabling multi-value indexes (e.g., indexing by each word in a name).
- *
- * @template M - The model class.
- * @template V - The computed index value type (for function-based indexes).
- * @template F - The field name (for single field index).
- * @template FS - The field names array (for composite index).
- * @param MyModel - The model class to create the index for.
- * @param field - Field name, array of field names, or a compute function.
- * @returns A new UniqueIndex instance.
- * 
- * @example
- * ```typescript
- * class User extends E.Model<User> {
- *   static byEmail = E.unique(User, "email");
- *   static byNameAge = E.unique(User, ["name", "age"]);
- *   static byFullName = E.unique(User, (u: User) => [`${u.firstName} ${u.lastName}`]);
- * }
- * ```
- */
-export function unique<M extends typeof Model, V>(MyModel: M, fn: (instance: InstanceType<M>) => V[]): UniqueIndex<M, [], [V]>;
-export function unique<M extends typeof Model, const F extends (keyof InstanceType<M> & string)>(MyModel: M, field: F): UniqueIndex<M, [F]>;
-export function unique<M extends typeof Model, const FS extends readonly (keyof InstanceType<M> & string)[]>(MyModel: M, fields: FS): UniqueIndex<M, FS>;
-
-export function unique(MyModel: typeof Model, fields: any): UniqueIndex<any, any, any> {
-    return new UniqueIndex(MyModel, typeof fields === 'string' ? [fields] : fields);
-}
-
-/**
- * Create a secondary index on model fields, or a computed secondary index using a function.
- *
- * For field-based indexes, pass a field name or array of field names.
- * For computed indexes, pass a function that takes a model instance and returns an array of
- * index keys. Return `[]` to skip indexing for that instance. Each array element creates a
- * separate index entry, enabling multi-value indexes (e.g., indexing by each word in a name).
- *
- * @template M - The model class.
- * @template V - The computed index value type (for function-based indexes).
- * @template F - The field name (for single field index).
- * @template FS - The field names array (for composite index).
- * @param MyModel - The model class to create the index for.
- * @param field - Field name, array of field names, or a compute function.
- * @returns A new SecondaryIndex instance.
- * 
- * @example
- * ```typescript
- * class User extends E.Model<User> {
- *   static byAge = E.index(User, "age");
- *   static byTagsDate = E.index(User, ["tags", "createdAt"]);
- *   static byWord = E.index(User, (u: User) => u.name.split(" "));
- * }
- * ```
- */
-export function index<M extends typeof Model, V>(MyModel: M, fn: (instance: InstanceType<M>) => V[]): SecondaryIndex<M, [], [V]>;
-export function index<M extends typeof Model, const F extends (keyof InstanceType<M> & string)>(MyModel: M, field: F): SecondaryIndex<M, [F]>;
-export function index<M extends typeof Model, const FS extends readonly (keyof InstanceType<M> & string)[]>(MyModel: M, fields: FS): SecondaryIndex<M, FS>;
-
-export function index(MyModel: typeof Model, fields: any): SecondaryIndex<any, any, any> {
-    return new SecondaryIndex(MyModel, typeof fields === 'string' ? [fields] : fields);
-}
-
 /**
  * Dump database contents for debugging.
  *