deepbase-indexeddb 3.4.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2023 mclasen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/README.md

@@ -0,0 +1,514 @@
+# 🌐 DeepBase IndexedDB Driver
+
+**Browser-based persistence using IndexedDB**
+
+The IndexedDB driver allows you to use DeepBase in browser environments with full offline capabilities. Perfect for Progressive Web Apps (PWAs), single-page applications, and any web app that needs reliable client-side storage.
+
+## ✨ Features
+
+- 🌐 **Browser-native**: Uses IndexedDB API built into modern browsers
+- 📴 **Offline-first**: Works without network connectivity
+- 💾 **Large storage**: Can store much more data than localStorage (typically hundreds of MBs)
+- 🔒 **Concurrency-safe**: Built-in operation queuing prevents race conditions
+- 🚀 **Fast**: Asynchronous operations with IndexedDB transactions
+- 🔄 **PWA-ready**: Perfect for Progressive Web Apps
+- 🛡️ **Type-safe**: Full support for nested objects and arrays
+- 🎯 **Same API**: Use the exact same DeepBase API in browser and Node.js
+
+## 📦 Installation
+
+```bash
+npm install deepbase deepbase-indexeddb
+```
+
+Or via CDN:
+
+```html
+<script type="module">
+  import DeepBase from 'https://cdn.skypack.dev/deepbase';
+  import IndexedDBDriver from 'https://cdn.skypack.dev/deepbase-indexeddb';
+  
+  // Your code here
+</script>
+```
+
+## 🚀 Quick Start
+
+### Basic Usage (Production)
+
+When using the published NPM packages:
+
+```javascript
+import DeepBase from 'deepbase';
+import IndexedDBDriver from 'deepbase-indexeddb';
+
+// Create database instance
+const db = new DeepBase(new IndexedDBDriver({
+  name: 'myapp',        // Database name
+  version: 1,           // Database version
+  storeName: 'store'    // Object store name (optional)
+}));
+
+// Connect to database
+await db.connect();
+
+// Store data
+await db.set('users', 'alice', { 
+  name: 'Alice', 
+  email: 'alice@example.com',
+  settings: {
+    theme: 'dark',
+    notifications: true
+  }
+});
+
+// Retrieve data
+const alice = await db.get('users', 'alice');
+console.log(alice.settings.theme); // 'dark'
+
+// Update nested values
+await db.set('users', 'alice', 'settings', 'theme', 'light');
+
+// Delete data
+await db.del('users', 'alice');
+
+// Disconnect when done
+await db.disconnect();
+```
+
+### Using with a Bundler (Webpack, Vite, etc.)
+
+For browser applications using a bundler, you can import normally:
+
+```javascript
+import DeepBase from 'deepbase';
+import IndexedDBDriver from 'deepbase-indexeddb';
+
+const db = new DeepBase(new IndexedDBDriver({
+  name: 'myapp',
+  version: 1
+}));
+
+await db.connect();
+// ... your code
+```
+
+### Using without a Bundler (Plain HTML)
+
+**Good news!** DeepBase now works directly in the browser thanks to dynamic imports:
+
+```html
+<script type="module">
+  // Import directly from local files
+  import DeepBase from './path/to/packages/core/src/index.js';
+  import { IndexedDBDriver } from './path/to/packages/driver-indexeddb/src/IndexedDBDriver.js';
+  
+  // Use the full DeepBase class with all features!
+  const db = new DeepBase(new IndexedDBDriver({
+    name: 'myapp',
+    version: 1
+  }));
+  
+  await db.connect();
+  await db.set('users', 'alice', { name: 'Alice' });
+  const alice = await db.get('users', 'alice');
+  console.log(alice);
+</script>
+```
+
+Or via CDN (once published):
+
+```html
+<script type="module">
+  import DeepBase from 'https://cdn.skypack.dev/deepbase';
+  import IndexedDBDriver from 'https://cdn.skypack.dev/deepbase-indexeddb';
+  
+  const db = new DeepBase(new IndexedDBDriver({
+    name: 'myapp',
+    version: 1
+  }));
+  
+  await db.connect();
+  // Your code here
+</script>
+```
+
+**Note:** The full DeepBase class now works in browsers! You get all features including multi-driver support, timeouts, and advanced operations.
+
+### Progressive Web App Example
+
+```javascript
+import DeepBase from 'deepbase';
+import IndexedDBDriver from 'deepbase-indexeddb';
+
+class TodoApp {
+  constructor() {
+    this.db = new DeepBase(new IndexedDBDriver({
+      name: 'todoapp',
+      version: 1
+    }));
+  }
+  
+  async init() {
+    await this.db.connect();
+    
+    // Initialize default data if needed
+    const todos = await this.db.get('todos');
+    if (!todos) {
+      await this.db.set('todos', {});
+    }
+  }
+  
+  async addTodo(text) {
+    const todoPath = await this.db.add('todos', {
+      text,
+      completed: false,
+      createdAt: Date.now()
+    });
+    return todoPath[1]; // Return the auto-generated ID
+  }
+  
+  async toggleTodo(id) {
+    await this.db.upd('todos', id, 'completed', val => !val);
+  }
+  
+  async getTodos() {
+    return await this.db.get('todos');
+  }
+  
+  async deleteTodo(id) {
+    await this.db.del('todos', id);
+  }
+}
+
+// Usage
+const app = new TodoApp();
+await app.init();
+
+const id = await app.addTodo('Learn DeepBase');
+console.log('Created todo:', id);
+
+await app.toggleTodo(id);
+const todos = await app.getTodos();
+console.log('All todos:', todos);
+```
+
+## 🎯 Configuration Options
+
+```javascript
+new IndexedDBDriver({
+  name: 'mydb',         // Database name (default: 'deepbase')
+  version: 1,           // Database version (default: 1)
+  storeName: 'store',   // Object store name (default: 'store')
+  
+  // Inherited from DeepBaseDriver:
+  nidAlphabet: 'ABC...', // Custom alphabet for auto-generated IDs
+  nidLength: 10          // Length of auto-generated IDs
+})
+```
+
+## 📚 API Reference
+
+The IndexedDB driver supports all standard DeepBase operations:
+
+### Basic Operations
+
+```javascript
+// Get value at path
+const value = await db.get('path', 'to', 'value');
+
+// Set value at path
+await db.set('path', 'to', 'value', 'hello');
+
+// Delete value at path
+await db.del('path', 'to', 'value');
+```
+
+### Array Operations
+
+```javascript
+// Add item with auto-generated ID
+const path = await db.add('items', { name: 'Item 1' });
+// Returns: ['items', 'aB3xK9mL2n']
+
+// Pop last item from array
+const item = await db.pop('myArray');
+
+// Shift first item from array
+const first = await db.shift('myArray');
+```
+
+### Numeric Operations
+
+```javascript
+// Increment number
+await db.inc('counter', 1);
+
+// Decrement number
+await db.dec('counter', 1);
+```
+
+### Update with Functions
+
+```javascript
+// Update value using a function
+await db.upd('user', 'name', name => name.toUpperCase());
+```
+
+### Object Operations
+
+```javascript
+// Get keys
+const keys = await db.keys('users');
+
+// Get values
+const values = await db.values('users');
+
+// Get entries
+const entries = await db.entries('users');
+```
+
+## 🔒 Concurrency Safety
+
+The IndexedDB driver includes built-in operation queuing to prevent race conditions:
+
+```javascript
+// These operations are safely serialized
+await Promise.all([
+  db.inc('counter', 1),
+  db.inc('counter', 1),
+  db.inc('counter', 1)
+]);
+
+const counter = await db.get('counter');
+console.log(counter); // Always 3, never less
+```
+
+## 🌐 Browser Compatibility
+
+The IndexedDB driver works in all modern browsers that support IndexedDB:
+
+- ✅ Chrome 24+
+- ✅ Firefox 16+
+- ✅ Safari 10+
+- ✅ Edge (all versions)
+- ✅ Opera 15+
+- ✅ Mobile browsers (iOS Safari, Chrome Mobile, etc.)
+
+## 💡 Use Cases
+
+### Progressive Web Apps (PWAs)
+
+```javascript
+// Store user preferences
+await db.set('preferences', {
+  theme: 'dark',
+  language: 'en',
+  notifications: true
+});
+
+// Cache API responses
+await db.set('cache', 'users', apiResponse);
+```
+
+### Offline-First Applications
+
+```javascript
+// Queue operations while offline
+if (!navigator.onLine) {
+  await db.add('syncQueue', {
+    action: 'updateUser',
+    data: userData,
+    timestamp: Date.now()
+  });
+}
+
+// Sync when back online
+window.addEventListener('online', async () => {
+  const queue = await db.get('syncQueue');
+  // Process queue...
+  await db.del('syncQueue');
+});
+```
+
+### Client-Side State Management
+
+```javascript
+// Store application state
+await db.set('app', 'state', {
+  currentUser: userId,
+  openModals: ['settings'],
+  cart: [item1, item2]
+});
+
+// Restore state on page load
+const state = await db.get('app', 'state');
+```
+
+### Form Data Persistence
+
+```javascript
+// Auto-save form data
+document.querySelector('#myForm').addEventListener('input', async (e) => {
+  await db.set('forms', 'contact', e.target.form.id, e.target.value);
+});
+
+// Restore form data
+const savedData = await db.get('forms', 'contact');
+```
+
+## 🔄 Multi-Driver Setup
+
+Combine IndexedDB with other drivers for advanced scenarios:
+
+```javascript
+import DeepBase from 'deepbase';
+import IndexedDBDriver from 'deepbase-indexeddb';
+import JsonDriver from 'deepbase-json';
+
+// Browser: Use IndexedDB
+// Node.js: Use JSON files
+const db = new DeepBase(
+  typeof window !== 'undefined'
+    ? new IndexedDBDriver({ name: 'myapp' })
+    : new JsonDriver({ path: './data', name: 'myapp' })
+);
+
+await db.connect();
+// Same code works in both environments!
+```
+
+## 🛠️ Advanced Features
+
+### Database Versioning
+
+```javascript
+// Upgrade database version when schema changes
+const db = new DeepBase(new IndexedDBDriver({
+  name: 'myapp',
+  version: 2  // Increment version number
+}));
+
+// IndexedDB will automatically handle the upgrade
+await db.connect();
+```
+
+### Multiple Object Stores
+
+```javascript
+// Create separate stores for different data types
+const usersDB = new DeepBase(new IndexedDBDriver({
+  name: 'myapp',
+  storeName: 'users'
+}));
+
+const postsDB = new DeepBase(new IndexedDBDriver({
+  name: 'myapp',
+  storeName: 'posts'
+}));
+
+await usersDB.connect();
+await postsDB.connect();
+```
+
+### Custom ID Generation
+
+```javascript
+const db = new DeepBase(new IndexedDBDriver({
+  name: 'myapp',
+  nidAlphabet: '0123456789',  // Numbers only
+  nidLength: 6                // 6 digits
+}));
+
+const path = await db.add('items', { name: 'Item' });
+// ID will be something like: ['items', '123456']
+```
+
+## ⚠️ Limitations
+
+- **Browser-only**: This driver only works in browser environments with IndexedDB support
+- **Storage limits**: Browser-dependent (typically 50-100MB, but can be more)
+- **Same-origin policy**: Data is isolated per domain
+- **Not suitable for**: Node.js, server-side rendering (SSR) initial render
+
+For Node.js environments, use:
+- `deepbase-json` for development
+- `deepbase-sqlite` for production
+- `deepbase-mongodb` for scalability
+- `deepbase-redis` for caching
+
+## 🔍 Debugging
+
+### Check Database in Browser DevTools
+
+1. Open Chrome DevTools
+2. Go to "Application" tab
+3. Expand "IndexedDB" in the sidebar
+4. Find your database name
+5. Inspect stored data
+
+### Common Issues
+
+**Error: "IndexedDB is not available"**
+- This driver requires a browser environment
+- Check that you're not running in Node.js
+- Ensure browser supports IndexedDB
+
+**Data not persisting**
+- Make sure to call `await db.connect()` before operations
+- Check browser storage settings/permissions
+- Verify you're not in private/incognito mode (some browsers restrict storage)
+
+## 📝 TypeScript Support
+
+```typescript
+import DeepBase from 'deepbase';
+import IndexedDBDriver from 'deepbase-indexeddb';
+
+interface User {
+  name: string;
+  email: string;
+  settings: {
+    theme: 'light' | 'dark';
+    notifications: boolean;
+  };
+}
+
+const db = new DeepBase(new IndexedDBDriver({
+  name: 'myapp'
+}));
+
+await db.connect();
+
+// TypeScript will infer types
+await db.set('users', 'alice', {
+  name: 'Alice',
+  email: 'alice@example.com',
+  settings: {
+    theme: 'dark',
+    notifications: true
+  }
+} as User);
+
+const alice = await db.get('users', 'alice') as User;
+```
+
+## 🤝 Contributing
+
+Found a bug or want to contribute? Check out the [main repository](https://github.com/clasen/DeepBase).
+
+## 📄 License
+
+MIT License - Copyright (c) Martin Clasen
+
+## 🔗 Links
+
+- [Main Documentation](https://github.com/clasen/DeepBase)
+- [GitHub Repository](https://github.com/clasen/DeepBase)
+- [Report Issues](https://github.com/clasen/DeepBase/issues)
+- [Other Drivers](https://github.com/clasen/DeepBase/tree/main/packages)
+
+---
+
+🚀 **Build amazing offline-first web apps with DeepBase + IndexedDB!**
+

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "deepbase-indexeddb",
+  "version": "3.4.0",
+  "description": "⚡ DeepBase IndexedDB - browser storage driver",
+  "type": "module",
+  "main": "src/index.cjs",
+  "module": "src/index.js",
+  "exports": {
+    ".": {
+      "require": "./src/index.cjs",
+      "import": "./src/index.js"
+    }
+  },
+  "dependencies": {},
+  "peerDependencies": {
+    "deepbase": "^3.4.0"
+  },
+  "scripts": {
+    "test": "echo \"IndexedDB tests require browser environment. See test/test.html\""
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/clasen/DeepBase.git"
+  },
+  "keywords": [
+    "deepbase",
+    "indexeddb",
+    "browser",
+    "driver",
+    "database",
+    "persist",
+    "nested",
+    "objects",
+    "offline",
+    "pwa"
+  ],
+  "author": "Martin Clasen",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/clasen/DeepBase/issues"
+  },
+  "homepage": "https://github.com/clasen/DeepBase/tree/main/packages/driver-indexeddb"
+}

package/src/IndexedDBDriver.js

@@ -0,0 +1,331 @@
+import { DeepBaseDriver } from 'deepbase';
+
+export class IndexedDBDriver extends DeepBaseDriver {
+  static _instances = {};
+  
+  constructor({name, version, storeName, ...opts} = {}) {
+    super(opts);
+    
+    this.name = name || "deepbase";
+    this.version = version || 1;
+    this.storeName = storeName || "store";
+    
+    this.db = null;
+    this._rootKey = '__root__';
+    
+    // Queue for serializing concurrent operations
+    this._operationQueue = Promise.resolve();
+    
+    // Singleton pattern per database name
+    const instanceKey = `${this.name}:${this.storeName}`;
+    if (IndexedDBDriver._instances[instanceKey]) {
+      return IndexedDBDriver._instances[instanceKey];
+    }
+    
+    IndexedDBDriver._instances[instanceKey] = this;
+  }
+  
+  async connect() {
+    if (this._connected) return;
+    
+    // Check if we're in a browser environment
+    if (typeof window === 'undefined' || !window.indexedDB) {
+      throw new Error('IndexedDB is not available. This driver only works in browser environments.');
+    }
+    
+    return new Promise((resolve, reject) => {
+      const request = indexedDB.open(this.name, this.version);
+      
+      request.onerror = () => {
+        reject(new Error(`Failed to open IndexedDB: ${request.error}`));
+      };
+      
+      request.onsuccess = () => {
+        this.db = request.result;
+        this._connected = true;
+        resolve();
+      };
+      
+      request.onupgradeneeded = (event) => {
+        const db = event.target.result;
+        
+        // Create object store if it doesn't exist
+        if (!db.objectStoreNames.contains(this.storeName)) {
+          db.createObjectStore(this.storeName);
+        }
+      };
+    });
+  }
+  
+  async disconnect() {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+      this._connected = false;
+    }
+  }
+  
+  async get(...args) {
+    if (!this._connected) {
+      throw new Error('Database not connected. Call connect() first.');
+    }
+    
+    // Get root object
+    const rootObj = await this._getRoot();
+    
+    // Navigate to the requested path
+    const value = this._getRecursive(rootObj, args.slice());
+    
+    // Return deep copy to prevent mutations
+    return typeof value === 'object' && value !== null 
+      ? JSON.parse(JSON.stringify(value))
+      : value;
+  }
+  
+  async set(...args) {
+    return this._queueOperation(async () => {
+      if (!this._connected) {
+        throw new Error('Database not connected. Call connect() first.');
+      }
+      
+      // Get root object
+      const rootObj = await this._getRoot();
+      
+      if (args.length < 2) {
+        // Setting the entire root
+        await this._setRoot(args[0]);
+        return [];
+      }
+      
+      const keys = args.slice(0, -1);
+      const value = args[args.length - 1];
+      
+      // Set value at path
+      this._setRecursive(rootObj, keys.slice(), value);
+      
+      // Save back to IndexedDB
+      await this._setRoot(rootObj);
+      
+      return keys;
+    });
+  }
+  
+  async del(...keys) {
+    return this._queueOperation(async () => {
+      if (!this._connected) {
+        throw new Error('Database not connected. Call connect() first.');
+      }
+      
+      if (keys.length === 0) {
+        // Delete entire root
+        await this._deleteRoot();
+        return;
+      }
+      
+      const rootObj = await this._getRoot();
+      const key = keys.pop();
+      const parentObj = this._getRecursive(rootObj, keys.slice());
+      
+      if (parentObj && parentObj.hasOwnProperty(key)) {
+        delete parentObj[key];
+        await this._setRoot(rootObj);
+      }
+    });
+  }
+  
+  async inc(...args) {
+    const i = args.pop();
+    return this.upd(...args, n => n + i);
+  }
+  
+  async dec(...args) {
+    const i = args.pop();
+    return this.upd(...args, n => n - i);
+  }
+  
+  async add(...keys) {
+    return this._queueOperation(async () => {
+      const value = keys.pop();
+      const id = this.nanoid();
+      await this._setInternal(...[...keys, id], value);
+      return [...keys, id];
+    });
+  }
+  
+  async upd(...args) {
+    return this._queueOperation(async () => {
+      if (!this._connected) {
+        throw new Error('Database not connected. Call connect() first.');
+      }
+      
+      const func = args.pop();
+      const rootObj = await this._getRoot();
+      const currentValue = this._getRecursive(rootObj, args.slice());
+      const newValue = func(currentValue);
+      await this._setInternal(...args, newValue);
+      return args;
+    });
+  }
+  
+  async pop(...args) {
+    return this._queueOperation(async () => {
+      if (!this._connected) {
+        throw new Error('Database not connected. Call connect() first.');
+      }
+      
+      const rootObj = await this._getRoot();
+      const arr = this._getRecursive(rootObj, args.slice());
+      
+      if (!Array.isArray(arr)) {
+        throw new Error('pop() can only be used on arrays');
+      }
+      
+      const poppedValue = arr.pop();
+      await this._setRoot(rootObj);
+      
+      return poppedValue;
+    });
+  }
+  
+  async shift(...args) {
+    return this._queueOperation(async () => {
+      if (!this._connected) {
+        throw new Error('Database not connected. Call connect() first.');
+      }
+      
+      const rootObj = await this._getRoot();
+      const arr = this._getRecursive(rootObj, args.slice());
+      
+      if (!Array.isArray(arr)) {
+        throw new Error('shift() can only be used on arrays');
+      }
+      
+      const shiftedValue = arr.shift();
+      await this._setRoot(rootObj);
+      
+      return shiftedValue;
+    });
+  }
+  
+  // Internal method to set without queuing
+  async _setInternal(...args) {
+    if (!this._connected) {
+      throw new Error('Database not connected. Call connect() first.');
+    }
+    
+    const rootObj = await this._getRoot();
+    
+    if (args.length < 2) {
+      await this._setRoot(args[0]);
+      return [];
+    }
+    
+    const keys = args.slice(0, -1);
+    const value = args[args.length - 1];
+    
+    this._setRecursive(rootObj, keys.slice(), value);
+    await this._setRoot(rootObj);
+    
+    return keys;
+  }
+  
+  // Queue operations to prevent race conditions
+  async _queueOperation(operation) {
+    const previousOperation = this._operationQueue;
+    
+    let resolver;
+    this._operationQueue = new Promise(resolve => {
+      resolver = resolve;
+    });
+    
+    try {
+      await previousOperation;
+      const result = await operation();
+      resolver();
+      return result;
+    } catch (error) {
+      resolver();
+      throw error;
+    }
+  }
+  
+  // Get root object from IndexedDB
+  async _getRoot() {
+    return new Promise((resolve, reject) => {
+      const transaction = this.db.transaction([this.storeName], 'readonly');
+      const store = transaction.objectStore(this.storeName);
+      const request = store.get(this._rootKey);
+      
+      request.onsuccess = () => {
+        resolve(request.result || {});
+      };
+      
+      request.onerror = () => {
+        reject(new Error(`Failed to get root: ${request.error}`));
+      };
+    });
+  }
+  
+  // Set root object in IndexedDB
+  async _setRoot(obj) {
+    return new Promise((resolve, reject) => {
+      const transaction = this.db.transaction([this.storeName], 'readwrite');
+      const store = transaction.objectStore(this.storeName);
+      const request = store.put(obj, this._rootKey);
+      
+      request.onsuccess = () => {
+        resolve();
+      };
+      
+      request.onerror = () => {
+        reject(new Error(`Failed to set root: ${request.error}`));
+      };
+    });
+  }
+  
+  // Delete root object from IndexedDB
+  async _deleteRoot() {
+    return new Promise((resolve, reject) => {
+      const transaction = this.db.transaction([this.storeName], 'readwrite');
+      const store = transaction.objectStore(this.storeName);
+      const request = store.delete(this._rootKey);
+      
+      request.onsuccess = () => {
+        resolve();
+      };
+      
+      request.onerror = () => {
+        reject(new Error(`Failed to delete root: ${request.error}`));
+      };
+    });
+  }
+  
+  _setRecursive(obj, keys, value) {
+    if (keys.length === 1) {
+      obj[keys[0]] = value;
+      return;
+    }
+    
+    const key = keys.shift();
+    if (!obj.hasOwnProperty(key) || typeof obj[key] !== "object") {
+      obj[key] = {};
+    }
+    
+    this._setRecursive(obj[key], keys, value);
+  }
+  
+  _getRecursive(obj, keys) {
+    if (keys.length === 0) return obj;
+    if (keys.length === 1) {
+      return obj === null || obj[keys[0]] === undefined ? null : obj[keys[0]];
+    }
+    
+    const key = keys.shift();
+    if (!obj.hasOwnProperty(key)) return null;
+    
+    return this._getRecursive(obj[key], keys);
+  }
+}
+
+export default IndexedDBDriver;
+

package/src/index.cjs

@@ -0,0 +1,2 @@
+module.exports = require('./index.js').default;
+

package/src/index.js

@@ -0,0 +1,4 @@
+import { IndexedDBDriver } from './IndexedDBDriver.js';
+export { IndexedDBDriver } from './IndexedDBDriver.js';
+export default IndexedDBDriver;
+

package/test/README.md

@@ -0,0 +1,58 @@
+# Testing IndexedDB Driver
+
+Since IndexedDB is a browser API, tests must be run in a browser environment.
+
+## Running Tests
+
+1. Open `test.html` in a web browser
+2. Tests will automatically run when the page loads
+3. You can also click "Run All Tests" button to re-run tests
+4. Use "Clear Database" to reset the test database
+
+## Test Files
+
+- `test.html` - Interactive browser-based test suite with visual feedback
+
+## Manual Testing
+
+You can also test manually using the browser console:
+
+```javascript
+import DeepBase from 'deepbase';
+import IndexedDBDriver from 'deepbase-indexeddb';
+
+const db = new DeepBase(new IndexedDBDriver({
+  name: 'manual-test',
+  version: 1
+}));
+
+await db.connect();
+
+// Test basic operations
+await db.set('test', 'value', 'hello');
+console.log(await db.get('test', 'value')); // 'hello'
+
+// Test nested operations
+await db.set('users', 'alice', { name: 'Alice', age: 30 });
+console.log(await db.get('users', 'alice'));
+
+await db.disconnect();
+```
+
+## Debugging
+
+Open Chrome DevTools:
+1. Go to "Application" tab
+2. Expand "IndexedDB" in the sidebar
+3. Find your database
+4. Inspect stored data
+
+## Browser Compatibility
+
+Tests should work in:
+- Chrome 24+
+- Firefox 16+
+- Safari 10+
+- Edge (all versions)
+- Opera 15+
+

package/test/test.html

@@ -0,0 +1,382 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>DeepBase IndexedDB Driver - Tests</title>
+  <style>
+    body {
+      font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+      max-width: 1200px;
+      margin: 0 auto;
+      padding: 20px;
+      background: #f5f5f5;
+    }
+    h1 {
+      color: #333;
+      border-bottom: 3px solid #4CAF50;
+      padding-bottom: 10px;
+    }
+    .test {
+      background: white;
+      margin: 10px 0;
+      padding: 15px;
+      border-radius: 5px;
+      box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+    }
+    .test.running {
+      background: #fff9c4;
+      border-left: 4px solid #FFC107;
+    }
+    .test.passed {
+      background: #e8f5e9;
+      border-left: 4px solid #4CAF50;
+    }
+    .test.failed {
+      background: #ffebee;
+      border-left: 4px solid #f44336;
+    }
+    .test-name {
+      font-weight: bold;
+      margin-bottom: 5px;
+    }
+    .test-result {
+      font-family: 'Courier New', monospace;
+      font-size: 12px;
+      color: #666;
+      margin-top: 5px;
+    }
+    .summary {
+      background: #333;
+      color: white;
+      padding: 20px;
+      border-radius: 5px;
+      margin-top: 20px;
+      font-size: 18px;
+    }
+    .summary.success {
+      background: #4CAF50;
+    }
+    .summary.failure {
+      background: #f44336;
+    }
+    .error {
+      color: #f44336;
+      font-family: 'Courier New', monospace;
+      font-size: 12px;
+      margin-top: 5px;
+      white-space: pre-wrap;
+    }
+    button {
+      background: #4CAF50;
+      color: white;
+      border: none;
+      padding: 10px 20px;
+      font-size: 16px;
+      border-radius: 5px;
+      cursor: pointer;
+      margin: 10px 5px;
+    }
+    button:hover {
+      background: #45a049;
+    }
+    button.danger {
+      background: #f44336;
+    }
+    button.danger:hover {
+      background: #da190b;
+    }
+  </style>
+</head>
+<body>
+  <h1>🧪 DeepBase IndexedDB Driver - Test Suite</h1>
+  
+  <div>
+    <button onclick="runTests()">Run All Tests</button>
+    <button onclick="clearDatabase()" class="danger">Clear Database</button>
+  </div>
+  
+  <div id="tests"></div>
+  <div id="summary"></div>
+
+  <script type="module">
+    // Import DeepBase (now works in browser without bundler thanks to dynamic imports!)
+    import DeepBase from '../../core/src/index.js';
+    import { IndexedDBDriver } from '../src/IndexedDBDriver.js';
+    
+    // Make available globally
+    window.DeepBase = DeepBase;
+    window.IndexedDBDriver = IndexedDBDriver;
+    
+    console.log('Modules loaded successfully');
+  </script>
+
+  <script>
+    let testResults = [];
+    let db;
+
+    async function clearDatabase() {
+      if (confirm('Are you sure you want to clear the test database?')) {
+        try {
+          if (db) {
+            await db.disconnect();
+          }
+          
+          // Delete the database
+          const request = indexedDB.deleteDatabase('deepbase-test');
+          
+          request.onsuccess = () => {
+            alert('Database cleared successfully');
+            document.getElementById('tests').innerHTML = '';
+            document.getElementById('summary').innerHTML = '';
+            testResults = [];
+          };
+          
+          request.onerror = () => {
+            alert('Failed to clear database');
+          };
+        } catch (error) {
+          alert('Error: ' + error.message);
+        }
+      }
+    }
+
+    async function runTests() {
+      testResults = [];
+      document.getElementById('tests').innerHTML = '';
+      document.getElementById('summary').innerHTML = '';
+
+      const tests = [
+        { name: 'Initialize database', fn: testInit },
+        { name: 'Set and get simple value', fn: testSetGet },
+        { name: 'Set and get nested value', fn: testNestedSetGet },
+        { name: 'Delete value', fn: testDelete },
+        { name: 'Increment number', fn: testIncrement },
+        { name: 'Decrement number', fn: testDecrement },
+        { name: 'Add with auto-generated ID', fn: testAdd },
+        { name: 'Update with function', fn: testUpdate },
+        { name: 'Get keys', fn: testKeys },
+        { name: 'Get values', fn: testValues },
+        { name: 'Get entries', fn: testEntries },
+        { name: 'Pop from array', fn: testPop },
+        { name: 'Shift from array', fn: testShift },
+        { name: 'Concurrent operations', fn: testConcurrency },
+        { name: 'Complex nested objects', fn: testComplexObjects },
+        { name: 'Disconnect', fn: testDisconnect }
+      ];
+
+      for (const test of tests) {
+        await runTest(test.name, test.fn);
+      }
+
+      displaySummary();
+    }
+
+    async function runTest(name, fn) {
+      const testDiv = document.createElement('div');
+      testDiv.className = 'test running';
+      testDiv.innerHTML = `
+        <div class="test-name">${name}</div>
+        <div class="test-result">Running...</div>
+      `;
+      document.getElementById('tests').appendChild(testDiv);
+
+      try {
+        const result = await fn();
+        testDiv.className = 'test passed';
+        testDiv.innerHTML = `
+          <div class="test-name">✓ ${name}</div>
+          <div class="test-result">${result || 'Passed'}</div>
+        `;
+        testResults.push({ name, passed: true });
+      } catch (error) {
+        testDiv.className = 'test failed';
+        testDiv.innerHTML = `
+          <div class="test-name">✗ ${name}</div>
+          <div class="error">${error.message}\n${error.stack}</div>
+        `;
+        testResults.push({ name, passed: false, error: error.message });
+      }
+    }
+
+    function displaySummary() {
+      const passed = testResults.filter(r => r.passed).length;
+      const total = testResults.length;
+      const summaryDiv = document.getElementById('summary');
+      summaryDiv.className = passed === total ? 'summary success' : 'summary failure';
+      summaryDiv.innerHTML = `
+        <strong>Test Results:</strong> ${passed}/${total} passed
+        ${passed < total ? '<br><br>Some tests failed. See details above.' : '<br><br>All tests passed! 🎉'}
+      `;
+    }
+
+    async function testInit() {
+      db = new window.DeepBase(new window.IndexedDBDriver({
+        name: 'deepbase-test',
+        version: 1
+      }));
+      await db.connect();
+      return 'Database initialized';
+    }
+
+    async function testSetGet() {
+      await db.set('test', 'value', 'hello');
+      const value = await db.get('test', 'value');
+      if (value !== 'hello') throw new Error(`Expected 'hello', got '${value}'`);
+      return `Value: ${value}`;
+    }
+
+    async function testNestedSetGet() {
+      await db.set('users', 'alice', { name: 'Alice', age: 30 });
+      const user = await db.get('users', 'alice');
+      if (user.name !== 'Alice' || user.age !== 30) {
+        throw new Error(`Unexpected user data: ${JSON.stringify(user)}`);
+      }
+      return `User: ${JSON.stringify(user)}`;
+    }
+
+    async function testDelete() {
+      await db.set('temp', 'data', 'delete me');
+      await db.del('temp', 'data');
+      const value = await db.get('temp', 'data');
+      if (value !== null) throw new Error(`Expected null, got '${value}'`);
+      return 'Value deleted successfully';
+    }
+
+    async function testIncrement() {
+      await db.set('counter', 10);
+      await db.inc('counter', 5);
+      const value = await db.get('counter');
+      if (value !== 15) throw new Error(`Expected 15, got ${value}`);
+      return `Counter: ${value}`;
+    }
+
+    async function testDecrement() {
+      await db.set('counter', 20);
+      await db.dec('counter', 7);
+      const value = await db.get('counter');
+      if (value !== 13) throw new Error(`Expected 13, got ${value}`);
+      return `Counter: ${value}`;
+    }
+
+    async function testAdd() {
+      const path = await db.add('items', { name: 'Item 1', price: 99 });
+      if (path.length !== 2 || path[0] !== 'items') {
+        throw new Error(`Unexpected path: ${JSON.stringify(path)}`);
+      }
+      const item = await db.get(...path);
+      if (item.name !== 'Item 1') throw new Error('Item not found');
+      return `Added item with ID: ${path[1]}`;
+    }
+
+    async function testUpdate() {
+      await db.set('user', 'name', 'john');
+      await db.upd('user', 'name', name => name.toUpperCase());
+      const value = await db.get('user', 'name');
+      if (value !== 'JOHN') throw new Error(`Expected 'JOHN', got '${value}'`);
+      return `Updated name: ${value}`;
+    }
+
+    async function testKeys() {
+      await db.set('products', 'laptop', { price: 999 });
+      await db.set('products', 'mouse', { price: 29 });
+      const keys = await db.keys('products');
+      if (!keys.includes('laptop') || !keys.includes('mouse')) {
+        throw new Error(`Unexpected keys: ${JSON.stringify(keys)}`);
+      }
+      return `Keys: ${JSON.stringify(keys)}`;
+    }
+
+    async function testValues() {
+      await db.set('products', 'laptop', { price: 999 });
+      await db.set('products', 'mouse', { price: 29 });
+      const values = await db.values('products');
+      if (values.length !== 2) throw new Error('Expected 2 values');
+      return `Values: ${JSON.stringify(values)}`;
+    }
+
+    async function testEntries() {
+      await db.set('products', 'laptop', { price: 999 });
+      await db.set('products', 'mouse', { price: 29 });
+      const entries = await db.entries('products');
+      if (entries.length !== 2) throw new Error('Expected 2 entries');
+      return `Entries: ${JSON.stringify(entries)}`;
+    }
+
+    async function testPop() {
+      await db.set('myArray', [1, 2, 3, 4, 5]);
+      const popped = await db.pop('myArray');
+      if (popped !== 5) throw new Error(`Expected 5, got ${popped}`);
+      const arr = await db.get('myArray');
+      if (arr.length !== 4) throw new Error(`Expected length 4, got ${arr.length}`);
+      return `Popped: ${popped}, Array: ${JSON.stringify(arr)}`;
+    }
+
+    async function testShift() {
+      await db.set('myArray', [1, 2, 3, 4, 5]);
+      const shifted = await db.shift('myArray');
+      if (shifted !== 1) throw new Error(`Expected 1, got ${shifted}`);
+      const arr = await db.get('myArray');
+      if (arr.length !== 4) throw new Error(`Expected length 4, got ${arr.length}`);
+      return `Shifted: ${shifted}, Array: ${JSON.stringify(arr)}`;
+    }
+
+    async function testConcurrency() {
+      await db.set('concurrentCounter', 0);
+      
+      // Run 10 increments concurrently
+      await Promise.all(
+        Array.from({ length: 10 }, () => db.inc('concurrentCounter', 1))
+      );
+      
+      const value = await db.get('concurrentCounter');
+      if (value !== 10) throw new Error(`Expected 10, got ${value} - race condition detected!`);
+      return `Counter after 10 concurrent increments: ${value}`;
+    }
+
+    async function testComplexObjects() {
+      const complexObj = {
+        user: {
+          id: 123,
+          profile: {
+            name: 'Alice',
+            email: 'alice@example.com',
+            settings: {
+              theme: 'dark',
+              notifications: {
+                email: true,
+                push: false
+              }
+            }
+          },
+          posts: [
+            { id: 1, title: 'First Post', tags: ['intro', 'hello'] },
+            { id: 2, title: 'Second Post', tags: ['update'] }
+          ]
+        }
+      };
+      
+      await db.set('complex', complexObj);
+      const retrieved = await db.get('complex');
+      
+      if (JSON.stringify(retrieved) !== JSON.stringify(complexObj)) {
+        throw new Error('Complex object not preserved correctly');
+      }
+      
+      return `Complex object stored and retrieved successfully`;
+    }
+
+    async function testDisconnect() {
+      await db.disconnect();
+      return 'Database disconnected';
+    }
+
+    // Auto-run tests when page loads
+    window.addEventListener('load', () => {
+      console.log('Page loaded, waiting 1 second before running tests...');
+      setTimeout(runTests, 1000);
+    });
+  </script>
+</body>
+</html>
+