@firtoz/drizzle-indexeddb 4.0.1 → 5.0.1

package/dist/context/useDrizzleIndexedDB.d.ts

@@ -0,0 +1,17 @@
+import { useIndexedDBCollection } from './DrizzleIndexedDBProvider.js';
+import { IDBDatabaseLike } from '../idb-types.js';
+import 'react/jsx-runtime';
+import 'react';
+import '@tanstack/db';
+import '@firtoz/db-helpers';
+import '@firtoz/drizzle-utils';
+import '../function-migrator.js';
+import '@firtoz/idb-collections';
+
+type UseDrizzleIndexedDBContextReturn<TSchema extends Record<string, unknown>> = {
+    useCollection: <TTableName extends keyof TSchema & string>(tableName: TTableName) => ReturnType<typeof useIndexedDBCollection<TSchema, TTableName>>;
+    indexedDB: IDBDatabaseLike | null;
+};
+declare function useDrizzleIndexedDB<TSchema extends Record<string, unknown>>(): UseDrizzleIndexedDBContextReturn<TSchema>;
+
+export { type UseDrizzleIndexedDBContextReturn, useDrizzleIndexedDB };

package/dist/context/useDrizzleIndexedDB.js

@@ -0,0 +1,8 @@
+export { useDrizzleIndexedDB } from '../chunk-HJFI7QKW.js';
+import '../chunk-Y6XE3FVT.js';
+import '../chunk-5KCMKETG.js';
+import '../chunk-7X4EIKN4.js';
+import '../chunk-JVUF63L6.js';
+import '../chunk-WMCUJFEC.js';
+//# sourceMappingURL=useDrizzleIndexedDB.js.map
+//# sourceMappingURL=useDrizzleIndexedDB.js.map

package/dist/context/useDrizzleIndexedDB.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"useDrizzleIndexedDB.js"}

package/dist/function-migrator.d.ts

@@ -0,0 +1,56 @@
+import { IDBCreator, IDBDatabaseLike } from './idb-types.js';
+import '@firtoz/idb-collections';
+
+interface CreateTableOperation {
+    type: "createTable";
+    name: string;
+    keyPath?: string;
+    autoIncrement?: boolean;
+    indexes?: Array<{
+        name: string;
+        keyPath: string | string[];
+        unique?: boolean;
+    }>;
+}
+interface DeleteTableOperation {
+    type: "deleteTable";
+    name: string;
+}
+interface CreateIndexOperation {
+    type: "createIndex";
+    tableName: string;
+    indexName: string;
+    keyPath: string | string[];
+    unique?: boolean;
+}
+interface DeleteIndexOperation {
+    type: "deleteIndex";
+    tableName: string;
+    indexName: string;
+}
+type MigrationOperation = CreateTableOperation | DeleteTableOperation | CreateIndexOperation | DeleteIndexOperation;
+/** A migration is an array of operations to perform */
+type Migration = MigrationOperation[];
+/**
+ * Runs IndexedDB migrations using declarative migration arrays.
+ * Version = total migrations + 1.
+ *
+ * Example usage:
+ * ```typescript
+ * 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);
+ * ```
+ */
+declare function migrateIndexedDBWithFunctions(dbName: string, migrations: Migration[], debug?: boolean, dbCreator?: IDBCreator): Promise<IDBDatabaseLike>;
+
+export { type CreateIndexOperation, type CreateTableOperation, type DeleteIndexOperation, type DeleteTableOperation, type Migration, type MigrationOperation, migrateIndexedDBWithFunctions };

package/dist/function-migrator.js

@@ -0,0 +1,5 @@
+export { migrateIndexedDBWithFunctions } from './chunk-7X4EIKN4.js';
+import './chunk-JVUF63L6.js';
+import './chunk-WMCUJFEC.js';
+//# sourceMappingURL=function-migrator.js.map
+//# sourceMappingURL=function-migrator.js.map

package/dist/function-migrator.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"function-migrator.js"}

package/dist/idb-interceptor.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Operation tracking for IndexedDB queries
+ * Useful for testing and debugging to verify what operations are actually performed
+ *
+ * Uses discriminated unions for type safety - TypeScript can narrow the type based on the 'type' field
+ */
+type IDBOperation = {
+    type: "getAll";
+    storeName: string;
+    itemsReturned: unknown[];
+    itemCount: number;
+    context?: string;
+    timestamp: number;
+} | {
+    type: "index-getAll";
+    storeName: string;
+    indexName: string;
+    keyRange?: IDBKeyRange;
+    itemsReturned: unknown[];
+    itemCount: number;
+    context?: string;
+    timestamp: number;
+} | {
+    type: "write";
+    storeName: string;
+    itemsWritten: unknown[];
+    writeCount: number;
+    context?: string;
+    timestamp: number;
+} | {
+    type: "get";
+    storeName: string;
+    key: IDBValidKey;
+    itemReturned?: unknown;
+    timestamp: number;
+} | {
+    type: "put";
+    storeName: string;
+    items: unknown[];
+    itemCount: number;
+    timestamp: number;
+} | {
+    type: "add";
+    storeName: string;
+    items: unknown[];
+    itemCount: number;
+    timestamp: number;
+} | {
+    type: "delete";
+    storeName: string;
+    keys: IDBValidKey[];
+    keyCount: number;
+    timestamp: number;
+} | {
+    type: "clear";
+    storeName: string;
+    timestamp: number;
+};
+/**
+ * Interceptor interface for tracking IndexedDB operations
+ * Allows tests and debugging tools to observe what operations are performed
+ */
+interface IDBInterceptor {
+    /** Called when any IndexedDB operation is performed */
+    onOperation?: (operation: IDBOperation) => void;
+}
+
+export type { IDBInterceptor, IDBOperation };

package/dist/idb-interceptor.js

@@ -0,0 +1,3 @@
+
+//# sourceMappingURL=idb-interceptor.js.map
+//# sourceMappingURL=idb-interceptor.js.map

package/dist/idb-interceptor.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"idb-interceptor.js"}

package/dist/idb-operations.d.ts

@@ -0,0 +1,13 @@
+import { IDBCreator, IDBOpenOptions, IDBDatabaseLike, IDBDeleter } from './idb-types.js';
+import '@firtoz/idb-collections';
+
+/**
+ * Opens an IndexedDB database using the provided creator or the default native implementation.
+ */
+declare function openIndexedDb(name: string, dbCreator?: IDBCreator, options?: IDBOpenOptions): Promise<IDBDatabaseLike>;
+/**
+ * Deletes an IndexedDB database (useful for testing)
+ */
+declare function deleteIndexedDB(dbName: string, dbDeleter?: IDBDeleter): Promise<void>;
+
+export { deleteIndexedDB, openIndexedDb };

package/dist/idb-operations.js

@@ -0,0 +1,4 @@
+export { deleteIndexedDB, openIndexedDb } from './chunk-JVUF63L6.js';
+import './chunk-WMCUJFEC.js';
+//# sourceMappingURL=idb-operations.js.map
+//# sourceMappingURL=idb-operations.js.map

package/dist/idb-operations.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"idb-operations.js"}

package/dist/idb-types.d.ts

@@ -0,0 +1,82 @@
+import { KeyRangeSpec } from '@firtoz/idb-collections';
+
+/**
+ * Index information returned by getStoreIndexes
+ */
+interface IndexInfo {
+    name: string;
+    keyPath: string | string[];
+}
+/**
+ * Options for creating an object store
+ */
+interface CreateStoreOptions {
+    keyPath?: string;
+    autoIncrement?: boolean;
+}
+/**
+ * Options for creating an index
+ */
+interface CreateIndexOptions {
+    unique?: boolean;
+}
+/**
+ * Minimal database interface with high-level async operations.
+ * This is the interface that custom implementations (mocks, Chrome extension proxies, etc.) need to implement.
+ *
+ * All operations are simple async functions - no transactions, requests, or callbacks to deal with.
+ */
+interface IDBDatabaseLike {
+    /** Database version number */
+    readonly version: number;
+    /** Check if a store exists */
+    hasStore(storeName: string): boolean;
+    /** Get list of all store names */
+    getStoreNames(): string[];
+    /** Create an object store (only valid during migrations) */
+    createStore(storeName: string, options?: CreateStoreOptions): void;
+    /** Delete an object store (only valid during migrations) */
+    deleteStore(storeName: string): void;
+    /** Create an index on a store (only valid during migrations) */
+    createIndex(storeName: string, indexName: string, keyPath: string | string[], options?: CreateIndexOptions): void;
+    /** Delete an index from a store (only valid during migrations) */
+    deleteIndex(storeName: string, indexName: string): void;
+    /** Get all indexes for a store (for index discovery) */
+    getStoreIndexes(storeName: string): IndexInfo[];
+    /** Get all items from a store */
+    getAll<T = unknown>(storeName: string): Promise<T[]>;
+    /** Get items from a store using an index with optional key range */
+    getAllByIndex<T = unknown>(storeName: string, indexName: string, keyRange?: KeyRangeSpec): Promise<T[]>;
+    /** Get a single item by key */
+    get<T = unknown>(storeName: string, key: IDBValidKey): Promise<T | undefined>;
+    /** Add items to a store (batch operation) */
+    add(storeName: string, items: unknown[]): Promise<void>;
+    /** Update items in a store (batch operation, uses put) */
+    put(storeName: string, items: unknown[]): Promise<void>;
+    /** Delete items from a store by keys (batch operation) */
+    delete(storeName: string, keys: IDBValidKey[]): Promise<void>;
+    /** Clear all items from a store */
+    clear(storeName: string): Promise<void>;
+    /** Close the database connection */
+    close(): void;
+}
+/**
+ * Options for opening a database with version upgrade support.
+ */
+interface IDBOpenOptions {
+    /** Target version for the database. If higher than current, triggers upgrade. */
+    version?: number;
+    /** Called during version upgrade - this is where schema changes (createStore, createIndex) are allowed. */
+    onUpgrade?: (db: IDBDatabaseLike) => void;
+}
+/**
+ * Function type for creating/opening an IndexedDB-like database.
+ * Custom implementations can use this to provide proxy/mock/alternative backends.
+ */
+type IDBCreator = (name: string, options?: IDBOpenOptions) => Promise<IDBDatabaseLike>;
+/**
+ * Function type for deleting an IndexedDB database.
+ */
+type IDBDeleter = (name: string) => Promise<void>;
+
+export type { CreateIndexOptions, CreateStoreOptions, IDBCreator, IDBDatabaseLike, IDBDeleter, IDBOpenOptions, IndexInfo };

package/dist/idb-types.js

@@ -0,0 +1,3 @@
+
+//# sourceMappingURL=idb-types.js.map
+//# sourceMappingURL=idb-types.js.map

package/dist/idb-types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"idb-types.js"}

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+export { CreateIndexOperation, CreateTableOperation, DeleteIndexOperation, DeleteTableOperation, Migration, MigrationOperation, migrateIndexedDBWithFunctions } from './function-migrator.js';
+export { CreateIndexOptions, CreateStoreOptions, IDBCreator, IDBDatabaseLike, IDBDeleter, IDBOpenOptions, IndexInfo } from './idb-types.js';
+export { IDBInterceptor, IDBOperation } from './idb-interceptor.js';
+export { deleteIndexedDB, openIndexedDb } from './idb-operations.js';
+export { defaultIDBCreator } from './native-idb-database.js';
+export { createInstrumentedDbCreator } from './instrumented-idb-database.js';
+export { DrizzleIndexedDBCollection, DrizzleIndexedDBCollectionConfig, DrizzleIndexedDBCollectionConfigResult, DrizzleIndexedDBSyncItem, drizzleIndexedDBCollectionOptions } from './collections/drizzle-indexeddb-collection.js';
+export { StandaloneCollection, StandaloneCollectionConfig, createStandaloneCollection } from './standalone-collection.js';
+export { DrizzleIndexedDBContext, DrizzleIndexedDBContextValue, DrizzleIndexedDBProvider, IndexedDbCollection, useIndexedDBCollection } from './context/DrizzleIndexedDBProvider.js';
+export { UseDrizzleIndexedDBContextReturn, useDrizzleIndexedDB } from './context/useDrizzleIndexedDB.js';
+import '@firtoz/idb-collections';
+import '@tanstack/db';
+import 'drizzle-orm';
+import '@firtoz/drizzle-utils';
+import '@firtoz/db-helpers';
+import 'react/jsx-runtime';
+import 'react';

package/dist/index.js

@@ -0,0 +1,10 @@
+export { createInstrumentedDbCreator } from './chunk-OSOLYU2M.js';
+export { createStandaloneCollection } from './chunk-CPLA7X66.js';
+export { useDrizzleIndexedDB } from './chunk-HJFI7QKW.js';
+export { DrizzleIndexedDBContext, DrizzleIndexedDBProvider, useIndexedDBCollection } from './chunk-Y6XE3FVT.js';
+export { drizzleIndexedDBCollectionOptions } from './chunk-5KCMKETG.js';
+export { migrateIndexedDBWithFunctions } from './chunk-7X4EIKN4.js';
+export { deleteIndexedDB, openIndexedDb } from './chunk-JVUF63L6.js';
+export { defaultIDBCreator } from './chunk-WMCUJFEC.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/instrumented-idb-database.d.ts

@@ -0,0 +1,17 @@
+import { IDBCreator } from './idb-types.js';
+import { IDBInterceptor } from './idb-interceptor.js';
+import '@firtoz/idb-collections';
+
+/**
+ * Creates an instrumented database creator that wraps operations with interception.
+ * Use this for testing to verify what IndexedDB operations are performed.
+ *
+ * @example
+ * const interceptor = { onOperation: (op) => console.log(op) };
+ * const dbCreator = createInstrumentedDbCreator(interceptor);
+ *
+ * <DrizzleIndexedDBProvider dbCreator={dbCreator} ... />
+ */
+declare function createInstrumentedDbCreator(interceptor: IDBInterceptor, baseCreator?: IDBCreator): IDBCreator;
+
+export { createInstrumentedDbCreator };

package/dist/instrumented-idb-database.js

@@ -0,0 +1,4 @@
+export { createInstrumentedDbCreator } from './chunk-OSOLYU2M.js';
+import './chunk-WMCUJFEC.js';
+//# sourceMappingURL=instrumented-idb-database.js.map
+//# sourceMappingURL=instrumented-idb-database.js.map

package/dist/instrumented-idb-database.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"instrumented-idb-database.js"}

package/dist/native-idb-database.d.ts

@@ -0,0 +1,9 @@
+import { IDBCreator } from './idb-types.js';
+import '@firtoz/idb-collections';
+
+/**
+ * Default IDB creator that uses the native IndexedDB API.
+ */
+declare const defaultIDBCreator: IDBCreator;
+
+export { defaultIDBCreator };

package/dist/native-idb-database.js

@@ -0,0 +1,3 @@
+export { defaultIDBCreator } from './chunk-WMCUJFEC.js';
+//# sourceMappingURL=native-idb-database.js.map
+//# sourceMappingURL=native-idb-database.js.map

package/dist/native-idb-database.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"native-idb-database.js"}

package/dist/standalone-collection.d.ts

@@ -0,0 +1,154 @@
+import { SyncMode, InferSchemaOutput, InferSchemaInput, Transaction, WritableDeep, Collection } from '@tanstack/db';
+import { Table } from 'drizzle-orm';
+import { CollectionUtils } from '@firtoz/db-helpers';
+import { SelectSchema, IdOf, InsertSchema, InsertToSelectSchema } from '@firtoz/drizzle-utils';
+import { Migration } from './function-migrator.js';
+import { IDBCreator, IDBDatabaseLike } from './idb-types.js';
+import '@firtoz/idb-collections';
+
+/**
+ * Configuration for creating a standalone IndexedDB collection
+ */
+interface StandaloneCollectionConfig<TTable extends Table> {
+    /**
+     * Name of the IndexedDB database
+     */
+    dbName: string;
+    /**
+     * The Drizzle table definition
+     */
+    table: TTable;
+    /**
+     * The name of the IndexedDB object store (defaults to table name)
+     */
+    storeName?: string;
+    /**
+     * Migrations to apply (optional)
+     */
+    migrations?: Migration[];
+    /**
+     * Custom database creator (for testing/mocking)
+     */
+    dbCreator?: IDBCreator;
+    /**
+     * Enable debug logging
+     */
+    debug?: boolean;
+    /**
+     * Sync mode: 'eager' (immediate) or 'lazy' (on-demand)
+     */
+    syncMode?: SyncMode;
+}
+/**
+ * Type for the underlying collection
+ */
+type InternalCollection<TTable extends Table> = Collection<InferSchemaOutput<SelectSchema<TTable>>, IdOf<TTable>, CollectionUtils<InferSchemaOutput<SelectSchema<TTable>>>, InsertToSelectSchema<TTable>, InferSchemaInput<InsertSchema<TTable>>>;
+/**
+ * Transaction type for mutations
+ */
+type MutationTransaction<TTable extends Table> = Transaction<InferSchemaOutput<SelectSchema<TTable>>>;
+/**
+ * Insert input type (what you pass to insert)
+ */
+type InsertInput<TTable extends Table> = InferSchemaInput<InsertSchema<TTable>>;
+/**
+ * Item type (what you get back from getAll, etc.)
+ */
+type ItemType<TTable extends Table> = InferSchemaOutput<SelectSchema<TTable>>;
+/**
+ * Writable draft type for update callbacks
+ */
+type DraftType<TTable extends Table> = WritableDeep<InsertInput<TTable>>;
+/**
+ * Standalone IndexedDB collection API
+ */
+interface StandaloneCollection<TTable extends Table> {
+    /**
+     * Promise that resolves when the collection is ready
+     */
+    ready: Promise<void>;
+    /**
+     * Check if the collection is ready (sync)
+     */
+    isReady(): boolean;
+    /**
+     * Get all items (sync - returns current state)
+     */
+    getAll(): ItemType<TTable>[];
+    /**
+     * Get an item by key (sync)
+     */
+    get(key: IdOf<TTable>): ItemType<TTable> | undefined;
+    /**
+     * Insert item(s)
+     * @returns Promise that resolves when persisted
+     */
+    insert(data: InsertInput<TTable> | InsertInput<TTable>[], callback?: (transaction: MutationTransaction<TTable>) => void): Promise<MutationTransaction<TTable>>;
+    /**
+     * Update an item by key using a callback that receives a draft
+     * @returns Promise that resolves when persisted
+     */
+    update(key: IdOf<TTable>, updater: (draft: DraftType<TTable>) => void, callback?: (transaction: MutationTransaction<TTable>) => void): Promise<MutationTransaction<TTable>>;
+    /**
+     * Delete item(s) by key
+     * @returns Promise that resolves when persisted
+     */
+    delete(key: IdOf<TTable> | IdOf<TTable>[], callback?: (transaction: MutationTransaction<TTable>) => void): Promise<MutationTransaction<TTable>>;
+    /**
+     * Clear all items from the store
+     * @returns Promise that resolves when truncate is complete
+     */
+    truncate(): Promise<void>;
+    /**
+     * Access to collection utils (truncate, receiveSync)
+     */
+    utils: CollectionUtils<ItemType<TTable>>;
+    /**
+     * The underlying TanStack DB collection (for advanced usage)
+     */
+    collection: InternalCollection<TTable>;
+    /**
+     * The IndexedDB database instance (available after ready)
+     */
+    db: IDBDatabaseLike | null;
+    /**
+     * Close the database connection
+     */
+    close(): void;
+}
+/**
+ * Create a standalone IndexedDB collection for use outside of React.
+ *
+ * @example
+ * ```ts
+ * const db = await createStandaloneCollection({
+ *   dbName: "myapp.db",
+ *   table: schema.todos,
+ *   migrations,
+ * });
+ *
+ * // Wait for ready
+ * await db.ready;
+ *
+ * // Get all items
+ * const items = db.getAll();
+ *
+ * // Insert
+ * await db.insert({ title: "New todo" });
+ *
+ * // Update
+ * await db.update(itemId, { title: "Updated" });
+ *
+ * // Delete
+ * await db.delete(itemId);
+ *
+ * // Truncate
+ * await db.truncate();
+ *
+ * // Clean up
+ * db.close();
+ * ```
+ */
+declare function createStandaloneCollection<TTable extends Table>(config: StandaloneCollectionConfig<TTable>): StandaloneCollection<TTable>;
+
+export { type StandaloneCollection, type StandaloneCollectionConfig, createStandaloneCollection };

package/dist/standalone-collection.js

@@ -0,0 +1,7 @@
+export { createStandaloneCollection } from './chunk-CPLA7X66.js';
+import './chunk-5KCMKETG.js';
+import './chunk-7X4EIKN4.js';
+import './chunk-JVUF63L6.js';
+import './chunk-WMCUJFEC.js';
+//# sourceMappingURL=standalone-collection.js.map
+//# sourceMappingURL=standalone-collection.js.map

package/dist/standalone-collection.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"standalone-collection.js"}

package/package.json

@@ -1,37 +1,40 @@
 {
 	"name": "@firtoz/drizzle-indexeddb",
-	"version": "4.0.1",
+	"version": "5.0.1",
 	"description": "IndexedDB migrations powered by Drizzle ORM",
-	"main": "./src/index.ts",
-	"module": "./src/index.ts",
-	"types": "./src/index.ts",
+	"main": "./dist/index.js",
+	"module": "./dist/index.js",
+	"types": "./dist/index.d.ts",
 	"type": "module",
 	"bin": {
-		"drizzle-indexeddb-generate": "./src/bin/generate-migrations.ts"
+		"drizzle-indexeddb-generate": "./dist/bin/generate-migrations.js"
 	},
 	"exports": {
 		".": {
-			"types": "./src/index.ts",
-			"import": "./src/index.ts",
-			"require": "./src/index.ts"
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js"
 		},
 		"./generate": {
-			"types": "./src/bin/generate-migrations.ts",
-			"import": "./src/bin/generate-migrations.ts",
-			"require": "./src/bin/generate-migrations.ts"
+			"types": "./dist/bin/generate-migrations.d.ts",
+			"import": "./dist/bin/generate-migrations.js"
 		},
-		"./*": {
-			"types": "./src/*.ts",
-			"import": "./src/*.ts",
-			"require": "./src/*.ts"
+		"./collections/*": {
+			"types": "./dist/collections/*.d.ts",
+			"import": "./dist/collections/*.js"
+		},
+		"./context/*": {
+			"types": "./dist/context/*.d.ts",
+			"import": "./dist/context/*.js"
 		},
-		"./*.tsx": {
-			"types": "./src/*.tsx",
-			"import": "./src/*.tsx",
-			"require": "./src/*.tsx"
+		"./*": {
+			"types": "./dist/*.d.ts",
+			"import": "./dist/*.js"
 		}
 	},
 	"files": [
+		"dist/**/*.js",
+		"dist/**/*.js.map",
+		"dist/**/*.d.ts",
 		"src/**/*.ts",
 		"src/**/*.tsx",
 		"!src/**/*.test.ts",
@@ -39,6 +42,8 @@
 		"CHANGELOG.md"
 	],
 	"scripts": {
+		"build": "tsup && bun ../../scripts/add-node-shebang.ts dist/bin/generate-migrations.js",
+		"prepack": "bun run build",
 		"typecheck": "tsgo --noEmit -p ./tsconfig.json",
 		"lint": "biome check --write src",
 		"lint:ci": "biome ci src",
@@ -68,26 +73,26 @@
 		"access": "public"
 	},
 	"peerDependencies": {
-		"@firtoz/drizzle-utils": ">=1.2.1",
-		"@tanstack/db": ">=0.6.3",
+		"@firtoz/drizzle-utils": ">=1.3.1",
+		"@tanstack/db": ">=0.6.5",
 		"drizzle-orm": ">=0.45.2",
 		"drizzle-valibot": ">=0.4.0",
-		"react": ">=19.2.4",
+		"react": ">=19.2.5",
 		"valibot": ">=1.3.1"
 	},
 	"devDependencies": {
-		"@firtoz/drizzle-utils": "^1.2.1",
-		"@tanstack/db": "^0.6.4",
+		"@firtoz/drizzle-utils": "^1.3.1",
+		"@tanstack/db": "^0.6.5",
 		"@types/react": "^19.2.14",
 		"drizzle-orm": "^0.45.2",
 		"drizzle-valibot": "^0.4.2",
-		"react": "^19.2.4",
+		"react": "^19.2.5",
 		"valibot": "^1.3.1"
 	},
 	"dependencies": {
-		"@firtoz/db-helpers": "^2.1.1",
-		"@firtoz/idb-collections": "^0.2.3",
-		"@firtoz/maybe-error": "^1.5.2",
-		"citty": "^0.2.1"
+		"@firtoz/db-helpers": "^2.2.1",
+		"@firtoz/idb-collections": "^0.3.1",
+		"@firtoz/maybe-error": "^1.6.1",
+		"citty": "^0.2.2"
 	}
 }