@firtoz/drizzle-indexeddb 0.4.1 → 0.4.3

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @firtoz/drizzle-indexeddb
 
+## 0.4.3
+
+### Patch Changes
+
+- [`ed6dfce`](https://github.com/firtoz/fullstack-toolkit/commit/ed6dfce75be95d5349381ab43c6c22b25b164414) Thanks [@firtoz](https://github.com/firtoz)! - Enable drizzle and output dir configuration in drizzle-indexeddb-generate
+
+## 0.4.2
+
+### Patch Changes
+
+- [`58afa0a`](https://github.com/firtoz/fullstack-toolkit/commit/58afa0a5365f55f536e50194a73f847293102e7f) Thanks [@firtoz](https://github.com/firtoz)! - Hopefully this should work
+
 ## 0.4.1
 
 ### Patch Changes

package/README.md

@@ -385,8 +385,8 @@ bun drizzle-indexeddb-generate --help
 
 | Option | Description | Default |
 |--------|-------------|---------|
-| `--drizzle-dir <path>` | Path to Drizzle directory | `./drizzle` |
-| `--output-dir <path>` | Path to output directory | `./drizzle/indexeddb-migrations` |
+| `--drizzle-dir <path>`, `-d` | Path to Drizzle directory | `./drizzle` |
+| `--output-dir <path>`, `-o` | Path to output directory | `<drizzle-dir>/indexeddb-migrations` |
 
 ### npm scripts
 
@@ -395,11 +395,13 @@ Add to your `package.json`:
 ```json
 {
   "scripts": {
-    "db:generate": "bun drizzle-kit generate && bun drizzle-indexeddb-generate"
+    "db:generate": "bun --bun drizzle-kit generate && bun drizzle-indexeddb-generate"
   }
 }
 ```
 
+> **Note:** The `--bun` flag forces bun's runtime instead of Node, which is needed because this package exports raw TypeScript. See [Troubleshooting](#err_unsupported_node_modules_type_stripping-error) if you encounter type stripping errors.
+
 ## Advanced Usage
 
 ### Custom Sync Configuration
@@ -666,6 +668,38 @@ Remove from schema and regenerate - the migrator will delete the object store.
 
 ## Troubleshooting
 
+### "ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING" Error
+
+If you see this error when running `drizzle-kit generate`:
+
+```
+Error [ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING]: Stripping types is currently unsupported for files under node_modules
+```
+
+This happens because this package exports raw TypeScript files, and Node's built-in type stripping doesn't work inside `node_modules`.
+
+**Solution:** Use `bun --bun` to force bun's runtime instead of Node:
+
+```bash
+bun --bun drizzle-kit generate
+```
+
+Or in your `package.json`:
+
+```json
+{
+  "scripts": {
+    "db:generate": "bun --bun drizzle-kit generate && bun drizzle-indexeddb-generate"
+  }
+}
+```
+
+**Alternative:** If you're not using bun, use `tsx`:
+
+```bash
+npx tsx node_modules/drizzle-kit/bin.cjs generate --config ./drizzle.config.ts
+```
+
 ### "Primary key structure changed" Error
 
 This happens when you change the primary key of a table. IndexedDB doesn't support changing keyPath after creation.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@firtoz/drizzle-indexeddb",
-	"version": "0.4.1",
+	"version": "0.4.3",
 	"description": "IndexedDB migrations powered by Drizzle ORM",
 	"main": "./src/index.ts",
 	"module": "./src/index.ts",
@@ -42,9 +42,7 @@
 		"typecheck": "tsc --noEmit -p ./tsconfig.json",
 		"lint": "biome check --write src",
 		"lint:ci": "biome ci src",
-		"format": "biome format src --write",
-		"test": "bun test --pass-with-no-tests",
-		"test:watch": "bun test --watch"
+		"format": "biome format src --write"
 	},
 	"keywords": [
 		"typescript",
@@ -69,17 +67,24 @@
 	"publishConfig": {
 		"access": "public"
 	},
-	"dependencies": {
+	"peerDependencies": {
+		"@firtoz/drizzle-utils": ">=0.3.0",
+		"@tanstack/db": ">=0.5.0",
+		"drizzle-orm": ">=0.44.0",
+		"drizzle-valibot": ">=0.4.0",
+		"react": ">=18.0.0",
+		"valibot": ">=1.0.0"
+	},
+	"devDependencies": {
 		"@firtoz/drizzle-utils": "^0.3.0",
 		"@tanstack/db": "^0.5.11",
+		"@types/react": "^19.2.7",
 		"drizzle-orm": "^0.45.0",
 		"drizzle-valibot": "^0.4.2",
+		"react": "^19.2.1",
 		"valibot": "^1.2.0"
 	},
-	"peerDependencies": {
-		"react": "^19.2.1"
-	},
-	"devDependencies": {
-		"@types/react": "^19.2.7"
+	"dependencies": {
+		"citty": "^0.1.6"
 	}
 }

package/src/bin/generate-migrations.ts

@@ -9,6 +9,7 @@
 
 import { readFileSync, writeFileSync, mkdirSync, existsSync } from "node:fs";
 import { join, resolve } from "node:path";
+import { defineCommand, runMain } from "citty";
 import type {
 	JournalEntry,
 	Journal,
@@ -240,49 +241,34 @@ export default migrations;
 }
 
 // CLI entry point
-function main(): void {
-	const args = process.argv.slice(2);
-	const command = args[0];
-
-	if (command === "generate" || command === undefined) {
-		// Parse options
-		const options: GenerateOptions = {};
-
-		for (let i = 1; i < args.length; i++) {
-			const arg = args[i];
-			if (arg === "--drizzle-dir" && args[i + 1]) {
-				options.drizzleDir = args[++i];
-			} else if (arg === "--output-dir" && args[i + 1]) {
-				options.outputDir = args[++i];
-			}
-		}
-
-		generateIndexedDBMigrations(options);
-	} else if (command === "--help" || command === "-h") {
-		console.log(`
-drizzle-indexeddb-generate - Generate IndexedDB migrations from Drizzle schema
-
-Usage:
-  bun drizzle-indexeddb-generate [options]
-
-Options:
-  --drizzle-dir <path>  Path to Drizzle directory (default: ./drizzle)
-  --output-dir <path>   Path to output directory (default: ./drizzle/indexeddb-migrations)
-  -h, --help            Show this help message
-
-Examples:
-  bun drizzle-indexeddb-generate
-  bun drizzle-indexeddb-generate --drizzle-dir ./db/drizzle
-  bun drizzle-indexeddb-generate --output-dir ./src/migrations
-`);
-	} else {
-		console.error(`Unknown command: ${command}`);
-		console.error(`Run 'bun drizzle-indexeddb-generate --help' for usage`);
-		process.exit(1);
-	}
-}
+const main = defineCommand({
+	meta: {
+		name: "drizzle-indexeddb-generate",
+		description: "Generate IndexedDB migrations from Drizzle schema",
+	},
+	args: {
+		drizzleDir: {
+			type: "string",
+			alias: "d",
+			default: "./drizzle",
+			description: "Path to Drizzle directory",
+		},
+		outputDir: {
+			type: "string",
+			alias: "o",
+			description:
+				"Path to output directory (default: <drizzle-dir>/indexeddb-migrations)",
+		},
+	},
+	run({ args }) {
+		generateIndexedDBMigrations({
+			drizzleDir: args.drizzleDir,
+			outputDir: args.outputDir,
+		});
+	},
+});
 
 // Only run CLI when executed directly (not when imported)
 if (import.meta.main) {
-	main();
+	runMain(main);
 }

package/src/context/DrizzleIndexedDBProvider.tsx

@@ -134,10 +134,9 @@ export function DrizzleIndexedDBProvider<
 	});
 
 	useEffect(() => {
+		let db: IDBDatabaseLike | null = null;
 		const initDB = async () => {
 			try {
-				let db: IDBDatabaseLike;
-
 				if (migrations.length === 0) {
 					// Open database directly without migration logic
 					db = await openIndexedDb(dbName, dbCreator);
@@ -161,11 +160,11 @@ export function DrizzleIndexedDBProvider<
 
 		// Cleanup on unmount
 		return () => {
-			if (indexedDB) {
-				indexedDB.close();
+			if (db) {
+				db.close();
 			}
 		};
-	}, [dbName, migrations, migrateFunction, debug, readyPromise]);
+	}, [dbName, migrations, migrateFunction, debug, readyPromise, dbCreator]);
 
 	// Collection cache with ref counting
 	const collections = useMemo<Map<string, CollectionCacheEntry>>(
@@ -219,15 +218,7 @@ export function DrizzleIndexedDBProvider<
 			return collections.get(cacheKey)!
 				.collection as unknown as IndexedDbCollection<TSchema, TTableName>;
 		},
-		[
-			indexedDBRef,
-			collections,
-			schema,
-			readyPromise.promise,
-			debug,
-			dbName,
-			syncMode,
-		],
+		[collections, schema, readyPromise.promise, debug, dbName, syncMode],
 	);
 
 	const incrementRefCount: DrizzleIndexedDBContextValue<TSchema>["incrementRefCount"] =

package/src/context/useDrizzleIndexedDB.ts

@@ -1,4 +1,4 @@
-import { useContext } from "react";
+import { useCallback, useContext } from "react";
 import {
 	DrizzleIndexedDBContext,
 	useIndexedDBCollection,
@@ -28,10 +28,15 @@ export function useDrizzleIndexedDB<
 		);
 	}
 
+	const useCollection = useCallback(
+		<TTableName extends keyof TSchema & string>(tableName: TTableName) =>
+			// biome-ignore lint/correctness/useHookAtTopLevel: This is on purpose.
+			useIndexedDBCollection(context, tableName),
+		[context],
+	);
+
 	return {
-		useCollection: <TTableName extends keyof TSchema & string>(
-			tableName: TTableName,
-		) => useIndexedDBCollection(context, tableName),
+		useCollection,
 		indexedDB: context.indexedDB,
 	};
 }

package/src/idb-operations.ts

@@ -23,9 +23,14 @@ export async function openIndexedDb(
  */
 const defaultIDBDeleter: IDBDeleter = (name: string): Promise<void> => {
 	return new Promise((resolve, reject) => {
-		const request = indexedDB.deleteDatabase(name);
-		request.onerror = () => reject(request.error);
-		request.onsuccess = () => resolve();
+		try {
+			const request = indexedDB.deleteDatabase(name);
+			request.onerror = () => reject(request.error);
+			request.onsuccess = () => resolve();
+		} catch (error) {
+			console.error("Error deleting database", error);
+			reject(error);
+		}
 	});
 };
 

package/src/native-idb-database.ts

@@ -104,12 +104,17 @@ class NativeIDBDatabase implements IDBDatabaseLike {
 		}
 
 		return new Promise((resolve, reject) => {
-			const transaction = this.db.transaction(storeName, "readonly");
-			const store = transaction.objectStore(storeName);
-			const request = store.getAll();
-
-			request.onsuccess = () => resolve(request.result as T[]);
-			request.onerror = () => reject(request.error);
+			try {
+				const transaction = this.db.transaction(storeName, "readonly");
+				const store = transaction.objectStore(storeName);
+				const request = store.getAll();
+
+				request.onsuccess = () => resolve(request.result as T[]);
+				request.onerror = () => reject(request.error);
+			} catch (error) {
+				console.error("Error getting all items", error);
+				reject(error);
+			}
 		});
 	}
 
@@ -119,14 +124,19 @@ class NativeIDBDatabase implements IDBDatabaseLike {
 		keyRange?: KeyRangeSpec,
 	): Promise<T[]> {
 		return new Promise((resolve, reject) => {
-			const transaction = this.db.transaction(storeName, "readonly");
-			const store = transaction.objectStore(storeName);
-			const index = store.index(indexName);
-			const range = keyRange ? createKeyRange(keyRange) : undefined;
-			const request = index.getAll(range);
-
-			request.onsuccess = () => resolve(request.result as T[]);
-			request.onerror = () => reject(request.error);
+			try {
+				const transaction = this.db.transaction(storeName, "readonly");
+				const store = transaction.objectStore(storeName);
+				const index = store.index(indexName);
+				const range = keyRange ? createKeyRange(keyRange) : undefined;
+				const request = index.getAll(range);
+
+				request.onsuccess = () => resolve(request.result as T[]);
+				request.onerror = () => reject(request.error);
+			} catch (error) {
+				console.error("Error getting all items by index", error);
+				reject(error);
+			}
 		});
 	}
 
@@ -135,72 +145,98 @@ class NativeIDBDatabase implements IDBDatabaseLike {
 		key: IDBValidKey,
 	): Promise<T | undefined> {
 		return new Promise((resolve, reject) => {
-			const transaction = this.db.transaction(storeName, "readonly");
-			const store = transaction.objectStore(storeName);
-			const request = store.get(key);
-
-			request.onsuccess = () => resolve(request.result as T | undefined);
-			request.onerror = () => reject(request.error);
+			try {
+				const transaction = this.db.transaction(storeName, "readonly");
+				const store = transaction.objectStore(storeName);
+				const request = store.get(key);
+
+				request.onsuccess = () => resolve(request.result as T | undefined);
+				request.onerror = () => reject(request.error);
+			} catch (error) {
+				console.error("Error getting item", error);
+				reject(error);
+			}
 		});
 	}
 
 	async add(storeName: string, items: unknown[]): Promise<void> {
 		return new Promise((resolve, reject) => {
-			const transaction = this.db.transaction(storeName, "readwrite");
-			const store = transaction.objectStore(storeName);
+			try {
+				const transaction = this.db.transaction(storeName, "readwrite");
+				const store = transaction.objectStore(storeName);
 
-			for (const item of items) {
-				store.add(item);
-			}
+				for (const item of items) {
+					store.add(item);
+				}
 
-			transaction.oncomplete = () => resolve();
-			transaction.onerror = () => reject(transaction.error);
-			transaction.onabort = () => reject(new Error("Transaction aborted"));
+				transaction.oncomplete = () => resolve();
+				transaction.onerror = () => reject(transaction.error);
+				transaction.onabort = () => reject(new Error("Transaction aborted"));
+			} catch (error) {
+				console.error("Error adding items", error);
+				reject(error);
+			}
 		});
 	}
 
 	async put(storeName: string, items: unknown[]): Promise<void> {
 		return new Promise((resolve, reject) => {
-			const transaction = this.db.transaction(storeName, "readwrite");
-			const store = transaction.objectStore(storeName);
+			try {
+				const transaction = this.db.transaction(storeName, "readwrite");
+				const store = transaction.objectStore(storeName);
 
-			for (const item of items) {
-				store.put(item);
-			}
+				for (const item of items) {
+					store.put(item);
+				}
 
-			transaction.oncomplete = () => resolve();
-			transaction.onerror = () => reject(transaction.error);
-			transaction.onabort = () => reject(new Error("Transaction aborted"));
+				transaction.oncomplete = () => resolve();
+				transaction.onerror = () => reject(transaction.error);
+				transaction.onabort = () => reject(new Error("Transaction aborted"));
+			} catch (error) {
+				console.error("Error putting items", error);
+				reject(error);
+			}
 		});
 	}
 
 	async delete(storeName: string, keys: IDBValidKey[]): Promise<void> {
 		return new Promise((resolve, reject) => {
-			const transaction = this.db.transaction(storeName, "readwrite");
-			const store = transaction.objectStore(storeName);
+			try {
+				const transaction = this.db.transaction(storeName, "readwrite");
+				const store = transaction.objectStore(storeName);
 
-			for (const key of keys) {
-				store.delete(key);
-			}
+				for (const key of keys) {
+					store.delete(key);
+				}
 
-			transaction.oncomplete = () => resolve();
-			transaction.onerror = () => reject(transaction.error);
-			transaction.onabort = () => reject(new Error("Transaction aborted"));
+				transaction.oncomplete = () => resolve();
+				transaction.onerror = () => reject(transaction.error);
+				transaction.onabort = () => reject(new Error("Transaction aborted"));
+			} catch (error) {
+				console.error("Error deleting items", error);
+				reject(error);
+			}
 		});
 	}
 
 	async clear(storeName: string): Promise<void> {
 		return new Promise((resolve, reject) => {
-			const transaction = this.db.transaction(storeName, "readwrite");
-			const store = transaction.objectStore(storeName);
-			const request = store.clear();
-
-			request.onsuccess = () => resolve();
-			request.onerror = () => reject(request.error);
+			try {
+				const transaction = this.db.transaction(storeName, "readwrite");
+				const store = transaction.objectStore(storeName);
+				const request = store.clear();
+
+				request.onsuccess = () => resolve();
+				request.onerror = () => reject(request.error);
+			} catch (error) {
+				console.error("Error clearing store", error);
+				reject(error);
+			}
 		});
 	}
 
 	close(): void {
+		console.log("Closing database");
 		this.db.close();
 	}
 }
@@ -319,37 +355,42 @@ export const defaultIDBCreator: IDBCreator = (
 	options?: IDBOpenOptions,
 ): Promise<IDBDatabaseLike> => {
 	return new Promise((resolve, reject) => {
-		const request = options?.version
-			? indexedDB.open(name, options.version)
-			: indexedDB.open(name);
-
-		request.onerror = () => reject(request.error);
+		try {
+			const request = options?.version
+				? indexedDB.open(name, options.version)
+				: indexedDB.open(name);
 
-		request.onblocked = () => {
-			setTimeout(() => {
-				reject(new Error("Database upgrade blocked - close other tabs"));
-			}, 3000);
-		};
+			request.onerror = () => reject(request.error);
 
-		request.onupgradeneeded = (event) => {
-			if (options?.onUpgrade) {
-				const db = request.result;
-				const transaction = (event.target as IDBOpenDBRequest).transaction;
-				if (!transaction) {
-					reject(new Error("No transaction during upgrade"));
-					return;
+			request.onblocked = () => {
+				setTimeout(() => {
+					reject(new Error("Database upgrade blocked - close other tabs"));
+				}, 3000);
+			};
+
+			request.onupgradeneeded = (event) => {
+				if (options?.onUpgrade) {
+					const db = request.result;
+					const transaction = (event.target as IDBOpenDBRequest).transaction;
+					if (!transaction) {
+						reject(new Error("No transaction during upgrade"));
+						return;
+					}
+					// Create an upgrade-mode database wrapper
+					const upgradeDb = new UpgradeModeDatabase(db, transaction);
+					try {
+						options.onUpgrade(upgradeDb);
+					} catch (error) {
+						transaction.abort();
+						reject(error);
+					}
 				}
-				// Create an upgrade-mode database wrapper
-				const upgradeDb = new UpgradeModeDatabase(db, transaction);
-				try {
-					options.onUpgrade(upgradeDb);
-				} catch (error) {
-					transaction.abort();
-					reject(error);
-				}
-			}
-		};
+			};
 
-		request.onsuccess = () => resolve(new NativeIDBDatabase(request.result));
+			request.onsuccess = () => resolve(new NativeIDBDatabase(request.result));
+		} catch (error) {
+			console.error("Error creating database", error);
+			reject(error);
+		}
 	});
 };