@firtoz/drizzle-indexeddb 0.2.0 → 0.3.0

package/src/function-migrator.ts

@@ -1,9 +1,54 @@
-// IndexedDB migrator that executes generated migration functions
+// IndexedDB migrator with declarative migration format
+
+import { type IDBCreator, type IDBDatabaseLike, openIndexedDb } from "./utils";
+
+// ============================================================================
+// Declarative Migration Types
+// ============================================================================
+
+export interface CreateTableOperation {
+	type: "createTable";
+	name: string;
+	keyPath?: string;
+	autoIncrement?: boolean;
+	indexes?: Array<{
+		name: string;
+		keyPath: string | string[];
+		unique?: boolean;
+	}>;
+}
+
+export interface DeleteTableOperation {
+	type: "deleteTable";
+	name: string;
+}
 
-export type IndexedDBMigrationFunction = (
-	db: IDBDatabase,
-	transaction: IDBTransaction,
-) => Promise<void>;
+export interface CreateIndexOperation {
+	type: "createIndex";
+	tableName: string;
+	indexName: string;
+	keyPath: string | string[];
+	unique?: boolean;
+}
+
+export interface DeleteIndexOperation {
+	type: "deleteIndex";
+	tableName: string;
+	indexName: string;
+}
+
+export type MigrationOperation =
+	| CreateTableOperation
+	| DeleteTableOperation
+	| CreateIndexOperation
+	| DeleteIndexOperation;
+
+/** A migration is an array of operations to perform */
+export type Migration = MigrationOperation[];
+
+// ============================================================================
+// Migration Record
+// ============================================================================
 
 interface MigrationRecord {
 	id: number;
@@ -12,160 +57,184 @@ interface MigrationRecord {
 
 const MIGRATIONS_STORE = "__drizzle_migrations";
 
+// ============================================================================
+// Migration Executor
+// ============================================================================
+
 /**
- * Runs IndexedDB migrations using generated migration functions
+ * Executes a single migration operation on the database.
+ */
+function executeMigrationOperation(
+	db: IDBDatabaseLike,
+	op: MigrationOperation,
+): void {
+	switch (op.type) {
+		case "createTable": {
+			if (!db.hasStore(op.name)) {
+				db.createStore(op.name, {
+					keyPath: op.keyPath,
+					autoIncrement: op.autoIncrement,
+				});
+				// Create indexes if specified
+				if (op.indexes) {
+					for (const idx of op.indexes) {
+						db.createIndex(op.name, idx.name, idx.keyPath, {
+							unique: idx.unique,
+						});
+					}
+				}
+			}
+			break;
+		}
+		case "deleteTable": {
+			if (db.hasStore(op.name)) {
+				db.deleteStore(op.name);
+			}
+			break;
+		}
+		case "createIndex": {
+			if (db.hasStore(op.tableName)) {
+				db.createIndex(op.tableName, op.indexName, op.keyPath, {
+					unique: op.unique,
+				});
+			}
+			break;
+		}
+		case "deleteIndex": {
+			if (db.hasStore(op.tableName)) {
+				db.deleteIndex(op.tableName, op.indexName);
+			}
+			break;
+		}
+	}
+}
+
+/**
+ * Executes a full migration (array of operations).
+ */
+function executeMigration(db: IDBDatabaseLike, migration: Migration): void {
+	for (const op of migration) {
+		executeMigrationOperation(db, op);
+	}
+}
+
+// ============================================================================
+// Main Migrator
+// ============================================================================
+
+/**
+ * Runs IndexedDB migrations using declarative migration arrays.
+ * Version = total migrations + 1.
  *
  * Example usage:
  * ```typescript
- * import { migrations } from './drizzle/indexeddb-migrations';
- * import { migrateIndexedDBWithFunctions } from '@firtoz/drizzle-indexeddb';
+ * const migrations: Migration[] = [
+ *   [
+ *     { type: "createTable", name: "todo", keyPath: "id", indexes: [
+ *       { name: "todo_user_id", keyPath: "user_id" }
+ *     ]}
+ *   ],
+ *   [
+ *     { type: "createTable", name: "user", keyPath: "id" }
+ *   ]
+ * ];
  *
- * const db = await migrateIndexedDBWithFunctions('my-db', migrations, true);
+ * const db = await migrateIndexedDBWithFunctions('my-db', migrations);
  * ```
  */
 export async function migrateIndexedDBWithFunctions(
 	dbName: string,
-	migrations: IndexedDBMigrationFunction[],
+	migrations: Migration[],
 	debug: boolean = false,
-): Promise<IDBDatabase> {
+	dbCreator?: IDBCreator,
+): Promise<IDBDatabaseLike> {
 	if (debug) {
-		console.log(
-			`[${new Date().toISOString()}] [PERF] IndexedDB migrator start for ${dbName}`,
-		);
+		console.log(`[IndexedDB] Starting migration for ${dbName}`);
 	}
 
-	// First, open the database to check which migrations have been applied
-	const currentDb = await openDatabaseForMigrationCheck(dbName);
-
-	const appliedMigrations = await getAppliedMigrations(currentDb);
+	const targetVersion = migrations.length + 1;
 
-	const latestAppliedIdx =
-		appliedMigrations.length > 0
-			? Math.max(...appliedMigrations.map((m) => m.id))
-			: -1;
+	// Open database to check current state
+	let db = await openIndexedDb(dbName, dbCreator);
+	const currentVersion = db.version;
 
 	if (debug) {
 		console.log(
-			`[${new Date().toISOString()}] [PERF] Latest applied migration index: ${latestAppliedIdx} (checked ${appliedMigrations.length} migrations)`,
+			`[IndexedDB] Current version: ${currentVersion}, Target: ${targetVersion}`,
 		);
 	}
 
-	// Determine which migrations need to be applied
+	// If already at target version, check if all migrations are recorded
+	if (currentVersion >= targetVersion) {
+		const applied = await getAppliedMigrations(db);
+		if (applied.length === migrations.length) {
+			if (debug) {
+				console.log("[IndexedDB] Already up to date");
+			}
+			return db;
+		}
+	}
+
+	// Get applied migrations before closing
+	const appliedMigrations = await getAppliedMigrations(db);
+	const appliedSet = new Set(appliedMigrations.map((m) => m.id));
+
+	// Find pending migrations
 	const pendingMigrations = migrations
-		.map((fn, idx) => ({ fn, idx }))
-		.filter(({ idx }) => idx > latestAppliedIdx);
+		.map((migration, idx) => ({ migration, idx }))
+		.filter(({ idx }) => !appliedSet.has(idx));
 
 	if (pendingMigrations.length === 0) {
 		if (debug) {
-			console.log(
-				`[${new Date().toISOString()}] [PERF] No pending migrations - database is up to date`,
-			);
-		}
-		currentDb.close();
-		// Re-open with correct version (migrations.length + 1 because version starts at 1)
-		const db = await openDatabase(dbName, migrations.length + 1);
-		if (debug) {
-			console.log(
-				`[${new Date().toISOString()}] [PERF] Migrator complete (no migrations needed)`,
-			);
+			console.log("[IndexedDB] No pending migrations");
 		}
 		return db;
 	}
 
 	if (debug) {
 		console.log(
-			`[${new Date().toISOString()}] [PERF] Found ${pendingMigrations.length} pending migrations to apply`,
+			`[IndexedDB] ${pendingMigrations.length} pending migrations to apply`,
 		);
 	}
 
-	currentDb.close();
-
-	// Calculate the target version (number of total migrations)
-	const targetVersion = migrations.length;
-
-	// Open database with version upgrade to trigger migration
-	const db = await new Promise<IDBDatabase>((resolve, reject) => {
-		// Use +1 here because first version is 1...
-		const request = indexedDB.open(dbName, targetVersion + 1);
-
-		request.onerror = () => reject(request.error);
-		request.onsuccess = () => {
-			resolve(request.result);
-		};
-
-		request.onupgradeneeded = async (event) => {
-			const db = (event.target as IDBOpenDBRequest).result;
-			const transaction = (event.target as IDBOpenDBRequest).transaction;
-
-			if (!transaction) {
-				reject(new Error("Transaction not available during upgrade"));
-				return;
-			}
-
-			if (debug) {
-				console.log(
-					`[${new Date().toISOString()}] [PERF] Upgrade started: v${event.oldVersion} → v${event.newVersion}`,
-				);
-			}
-
-			try {
-				// Ensure migrations store exists
-				if (!db.objectStoreNames.contains(MIGRATIONS_STORE)) {
-					const migrationStore = db.createObjectStore(MIGRATIONS_STORE, {
-						keyPath: "id",
-						autoIncrement: false,
-					});
-					migrationStore.createIndex("appliedAt", "appliedAt", {
-						unique: false,
-					});
-					if (debug) {
-						console.log(
-							`[${new Date().toISOString()}] [PERF] Created migrations tracking store`,
-						);
-					}
-				}
-
-				// Apply each pending migration
-				for (const { fn, idx } of pendingMigrations) {
-					if (debug) {
-						console.log(
-							`[${new Date().toISOString()}] [PERF] Applying migration ${idx}...`,
-						);
-					}
-
-					// Execute the migration function
-					await fn(db, transaction);
-
-					// Record the migration
-					const migrationStore = transaction.objectStore(MIGRATIONS_STORE);
-					migrationStore.add({
-						id: idx,
-						appliedAt: Date.now(),
-					});
-
-					if (debug) {
-						console.log(
-							`[${new Date().toISOString()}] [PERF] Migration ${idx} complete`,
-						);
-					}
+	// Close to allow version upgrade
+	db.close();
+
+	// Open with target version, running migrations during upgrade
+	await openIndexedDb(dbName, dbCreator, {
+		version: targetVersion,
+		onUpgrade: (upgradeDb) => {
+			// Ensure migrations store exists
+			if (!upgradeDb.hasStore(MIGRATIONS_STORE)) {
+				upgradeDb.createStore(MIGRATIONS_STORE, {
+					keyPath: "id",
+					autoIncrement: false,
+				});
+				if (debug) {
+					console.log("[IndexedDB] Created migrations store");
 				}
+			}
 
+			// Run pending migrations
+			for (const { migration, idx } of pendingMigrations) {
 				if (debug) {
-					console.log(
-						`[${new Date().toISOString()}] [PERF] All ${pendingMigrations.length} migrations applied successfully`,
-					);
+					console.log(`[IndexedDB] Running migration ${idx}`);
 				}
-			} catch (error) {
-				console.error("[IndexedDBMigrator] Migration failed:", error);
-				transaction.abort();
-				reject(error);
+				executeMigration(upgradeDb, migration);
 			}
-		};
+		},
 	});
 
+	// Reopen normally and record applied migrations
+	db = await openIndexedDb(dbName, dbCreator);
+
+	for (const { idx } of pendingMigrations) {
+		await db.add(MIGRATIONS_STORE, [{ id: idx, appliedAt: Date.now() }]);
+	}
+
 	if (debug) {
 		console.log(
-			`[${new Date().toISOString()}] [PERF] Migrator complete - database ready`,
+			`[IndexedDB] Applied ${pendingMigrations.length} migrations, now at version ${targetVersion}`,
 		);
 	}
 
@@ -173,62 +242,13 @@ export async function migrateIndexedDBWithFunctions(
 }
 
 /**
- * Opens database for checking migrations (without triggering upgrade)
- */
-async function openDatabaseForMigrationCheck(
-	dbName: string,
-): Promise<IDBDatabase> {
-	return new Promise((resolve, reject) => {
-		const request = indexedDB.open(dbName);
-		request.onerror = () => {
-			reject(request.error);
-		};
-		request.onsuccess = () => {
-			resolve(request.result);
-		};
-	});
-}
-
-/**
- * Opens database with a specific version
- */
-async function openDatabase(
-	dbName: string,
-	version: number,
-): Promise<IDBDatabase> {
-	return new Promise((resolve, reject) => {
-		const request = indexedDB.open(dbName, version);
-		request.onerror = () => {
-			reject(request.error);
-		};
-		request.onsuccess = () => {
-			resolve(request.result);
-		};
-	});
-}
-
-/**
- * Gets the list of applied migrations from the database
+ * Gets applied migrations from the database.
  */
 async function getAppliedMigrations(
-	db: IDBDatabase,
+	db: IDBDatabaseLike,
 ): Promise<MigrationRecord[]> {
-	if (!db.objectStoreNames.contains(MIGRATIONS_STORE)) {
+	if (!db.hasStore(MIGRATIONS_STORE)) {
 		return [];
 	}
-
-	return new Promise((resolve, reject) => {
-		const transaction = db.transaction(MIGRATIONS_STORE, "readonly");
-
-		const store = transaction.objectStore(MIGRATIONS_STORE);
-
-		const request = store.getAll();
-
-		request.onerror = () => {
-			reject(request.error);
-		};
-		request.onsuccess = () => {
-			resolve(request.result);
-		};
-	});
+	return db.getAll<MigrationRecord>(MIGRATIONS_STORE);
 }

package/src/index.ts

@@ -1,14 +1,23 @@
-export {
-	migrateIndexedDB,
-	type IndexedDBMigrationConfig,
-} from "./snapshot-migrator";
-
 export {
 	migrateIndexedDBWithFunctions,
-	type IndexedDBMigrationFunction,
+	type Migration,
+	type MigrationOperation,
+	type CreateTableOperation,
+	type DeleteTableOperation,
+	type CreateIndexOperation,
+	type DeleteIndexOperation,
 } from "./function-migrator";
 
-export { deleteIndexedDB } from "./utils";
+export {
+	deleteIndexedDB,
+	type IDBCreator,
+	type IDBOpenOptions,
+	type IDBDatabaseLike,
+	type IndexInfo,
+	type CreateStoreOptions,
+	type CreateIndexOptions,
+	type KeyRangeSpec,
+} from "./utils";
 
 export {
 	indexedDBCollectionOptions,