edinburgh 0.4.6 → 0.6.0

package/src/migrate.ts

@@ -1,10 +1,9 @@
 import * as lowlevel from "olmdb/lowlevel";
 import DataPack from "./datapack.js";
-import { modelRegistry, currentTxn, Transaction } from "./models.js";
+import { currentTxn, type Transaction, transact } from "./edinburgh.js";
+import { modelRegistry } 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";
 
 const INDEX_ID_PREFIX = -2;
 
@@ -118,14 +117,13 @@ 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 });
-        for (const sec of model._secondaries || []) {
+        knownIndexIds.add(model._indexId!);
+        modelByPkIndexId.set(model._indexId!, model);
+        for (const sec of Object.values(model._secondaries || {})) {
             knownIndexIds.add(sec._indexId!);
         }
     }
@@ -155,24 +153,24 @@ 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;
-            const secondaries = model._secondaries || [];
+            const secondaries = Object.values(model._secondaries || {});
 
             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._indexFields.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 as any, preMigrate)) secondaryCount++;
                         }
                     }
                 }
 
                 // Rewrite primary row data to current version
                 if (rewriteData) {
-                    primary._write(txn, keyBuf, record);
+                    model._writePK(txn, keyBuf, record);
                     rewrittenCount++;
                 }
             });
@@ -245,7 +224,6 @@ export async function runMigration(options: MigrationOptions = {}): Promise<Migr
             const failures: Record<string, number> = {};
 
             await forEachRow(oldDef.id, (txn, keyBuf) => {
-                let instance;
                 try {
                     // Deserialize old key
                     const keyPack = new DataPack(keyBuf);
@@ -260,7 +238,7 @@ export async function runMigration(options: MigrationOptions = {}): Promise<Migr
                     if (migrateFn) migrateFn(record);
 
                     // _write validates, checks duplicates, writes primary + secondaries
-                    instance = new (model as any)(record, txn);
+                    let instance = new (model as any)(record, txn);
                     instance._write(txn);
                     dbDel(txn.id, keyBuf);
                     converted++;
@@ -271,7 +249,7 @@ export async function runMigration(options: MigrationOptions = {}): Promise<Migr
                         failures['error'] = (failures['error'] || 0) + 1;
                     }
                 } finally {
-                    if (instance) txn.instances.delete(instance);
+                    txn.instances.clear(); // We've already handled the _write() ourselves
                 }
             });