deepbase-sqlite 3.0.0

package/LICENSE

@@ -0,0 +1,23 @@
+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,205 @@
+# deepbase-sqlite
+
+SQLite driver for DeepBase.
+
+## Installation
+
+```bash
+npm install deepbase deepbase-sqlite
+```
+
+## Description
+
+Stores data in SQLite database files. Perfect for:
+
+- ✅ Production applications
+- ✅ Medium to large datasets
+- ✅ Fast queries and transactions
+- ✅ ACID compliance
+- ✅ Embedded database solution
+- ✅ Zero configuration needed
+
+## Usage
+
+```javascript
+import DeepBase from 'deepbase';
+import SqliteDriver from 'deepbase-sqlite';
+
+const db = new DeepBase(new SqliteDriver({
+  path: './data',
+  name: 'mydb'
+}));
+
+await db.connect();
+
+await db.set('users', 'alice', { name: 'Alice', age: 30 });
+const alice = await db.get('users', 'alice');
+```
+
+## Options
+
+```javascript
+new SqliteDriver({
+  path: './data',              // Directory to store database files
+  name: 'default',            // Database filename (without .db)
+  nidAlphabet: 'ABC...',      // Alphabet for ID generation
+  nidLength: 10               // Length of generated IDs
+})
+```
+
+## Features
+
+### High Performance
+
+Uses `better-sqlite3` for synchronous operations wrapped in async API:
+
+- Prepared statements for optimal performance
+- Transaction support for batch operations
+- Fast lookups with indexed keys
+
+### Singleton Pattern
+
+Multiple instances pointing to the same database file will share the same connection:
+
+```javascript
+const db1 = new DeepBase(new SqliteDriver({ name: 'mydb' }));
+const db2 = new DeepBase(new SqliteDriver({ name: 'mydb' }));
+// Both use the same underlying database connection
+```
+
+### Nested Data Structure
+
+Efficiently stores nested objects using a key-value schema:
+
+- Keys are stored as dot-notation paths (e.g., `user.profile.name`)
+- Values are stored as JSON
+- Fast lookups for both exact keys and partial paths
+
+### ACID Compliance
+
+SQLite provides:
+
+- **Atomicity**: All operations complete or none do
+- **Consistency**: Data remains valid across transactions
+- **Isolation**: Concurrent operations don't interfere
+- **Durability**: Committed data persists even after crashes
+
+## Database Structure
+
+Data is stored in a simple key-value table:
+
+```sql
+CREATE TABLE deepbase (
+  key TEXT PRIMARY KEY,
+  value TEXT NOT NULL
+)
+```
+
+Example data:
+
+```
+key                    | value
+-----------------------|------------------
+users.alice.name       | "Alice"
+users.alice.age        | 30
+users.bob.name         | "Bob"
+users.bob.age          | 25
+config.theme           | "dark"
+config.lang            | "en"
+```
+
+## Use Cases
+
+- **Production Apps**: Reliable embedded database for web/desktop apps
+- **Medium Datasets**: Handles millions of records efficiently
+- **Offline First**: Works without network or external database server
+- **Desktop Apps**: Perfect for Electron or Tauri applications
+- **Mobile Apps**: Lightweight database for React Native/Capacitor
+- **IoT Devices**: Embedded storage for edge computing
+- **Serverless**: Deploy with your functions, no external DB needed
+
+## Performance
+
+SQLite offers excellent performance:
+
+- Fast reads and writes with prepared statements
+- Efficient indexing for quick lookups
+- Transaction batching for bulk operations
+- Low memory footprint
+
+## Migration
+
+Easy to migrate between SQLite and other drivers:
+
+```javascript
+import DeepBase from 'deepbase';
+import SqliteDriver from 'deepbase-sqlite';
+import MongoDriver from 'deepbase-mongodb';
+
+const db = new DeepBase([
+  new SqliteDriver({ path: './data' }),
+  new MongoDriver({ url: 'mongodb://localhost:27017' })
+]);
+
+await db.connect();
+await db.migrate(0, 1); // Migrate SQLite to MongoDB
+```
+
+## File Structure
+
+Data is stored as SQLite database files:
+
+```
+data/
+  mydb.db
+  users.db
+  config.db
+```
+
+## Comparison with JSON Driver
+
+| Feature | SQLite | JSON |
+|---------|--------|------|
+| Performance | ⚡ Very Fast | 🐌 Slower for large data |
+| File Size | 📦 Compact | 📄 Human readable |
+| Transactions | ✅ ACID | ❌ No transactions |
+| Query Speed | 🚀 Indexed | 🔍 Full scan |
+| Reliability | 💪 Very High | ⚠️ File corruption risk |
+| Debugging | 🔧 SQL tools | 👁️ Easy to inspect |
+
+## Best Practices
+
+### Use Transactions for Bulk Operations
+
+```javascript
+// Better: Use root object set for bulk inserts
+const data = {
+  user1: { name: 'Alice' },
+  user2: { name: 'Bob' },
+  user3: { name: 'Charlie' }
+};
+await db.set('users', data);
+```
+
+### Disconnect Properly
+
+```javascript
+// Always disconnect to close database connection
+await db.disconnect();
+```
+
+### Use Appropriate Paths
+
+```javascript
+// Good: Organize data hierarchically
+await db.set('users', userId, 'profile', data);
+
+// Avoid: Flat structure loses benefits of nesting
+await db.set(`user_${userId}_profile`, data);
+```
+
+## License
+
+MIT - Copyright (c) Martin Clasen
+
+

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "deepbase-sqlite",
+  "version": "3.0.0",
+  "description": "⚡ DeepBase SQLite - SQLite database driver",
+  "type": "module",
+  "main": "src/index.js",
+  "module": "src/index.js",
+  "exports": {
+    ".": {
+      "import": "./src/index.js"
+    }
+  },
+  "dependencies": {
+    "better-sqlite3": "^11.8.1"
+  },
+  "peerDependencies": {
+    "deepbase": "^3.0.0"
+  },
+  "scripts": {
+    "test": "mocha test/test.js"
+  },
+  "devDependencies": {
+    "mocha": "^10.8.2"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/clasen/DeepBase.git"
+  },
+  "keywords": [
+    "deepbase",
+    "sqlite",
+    "sqlite3",
+    "driver",
+    "database",
+    "persist",
+    "nested",
+    "objects"
+  ],
+  "author": "Martin Clasen",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/clasen/DeepBase/issues"
+  },
+  "homepage": "https://github.com/clasen/DeepBase#readme"
+}
+
+

package/src/SqliteDriver.js

@@ -0,0 +1,303 @@
+import { DeepBaseDriver } from 'deepbase';
+import Database from 'better-sqlite3';
+import fs from 'fs';
+import * as pathModule from 'path';
+import { customAlphabet } from 'nanoid';
+
+export class SqliteDriver extends DeepBaseDriver {
+  static _instances = {};
+  
+  constructor({name, path, ...opts} = {}) {
+    super(opts);
+    
+    this.name = name || "default";
+    this.path = path || './db';
+    this.nanoid = customAlphabet(this.nidAlphabet, this.nidLength);
+    
+    this.path = pathModule.resolve(this.path);
+    this.fileName = pathModule.join(this.path, `${this.name}.db`);
+    
+    // Singleton pattern per file
+    if (SqliteDriver._instances[this.fileName]) {
+      return SqliteDriver._instances[this.fileName];
+    }
+    
+    this.db = null;
+    SqliteDriver._instances[this.fileName] = this;
+  }
+  
+  async connect() {
+    if (!fs.existsSync(this.path)) {
+      fs.mkdirSync(this.path, { recursive: true });
+    }
+    
+    this.db = new Database(this.fileName);
+    
+    // Create table if it doesn't exist
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS deepbase (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      )
+    `);
+    
+    // Prepare statements for better performance
+    this.getStmt = this.db.prepare('SELECT value FROM deepbase WHERE key = ?');
+    this.setStmt = this.db.prepare('INSERT OR REPLACE INTO deepbase (key, value) VALUES (?, ?)');
+    this.delStmt = this.db.prepare('DELETE FROM deepbase WHERE key = ?');
+    this.getAllStmt = this.db.prepare('SELECT key, value FROM deepbase');
+    this.getKeysLikeStmt = this.db.prepare('SELECT key, value FROM deepbase WHERE key LIKE ?');
+  }
+  
+  async disconnect() {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+  }
+  
+  async get(...args) {
+    if (args.length === 0) {
+      // Get root object
+      return this._getRootObject();
+    }
+    
+    const key = this._pathToKey(args);
+    const row = this.getStmt.get(key);
+    
+    // Check if there are child keys (nested properties)
+    const childKey = key + '.';
+    const children = this.getKeysLikeStmt.all(childKey + '%');
+    
+    // If there are children, build object from them
+    if (children.length > 0) {
+      return this._buildObjectFromChildren(key);
+    }
+    
+    // If direct key exists and no children, return it
+    if (row) {
+      return JSON.parse(row.value);
+    }
+    
+    // Check if we need to look into a parent object
+    // For example: if we're looking for 'users.abc.name' but only 'users.abc' exists as a JSON object
+    const parentPath = this._findParentWithValue(args);
+    if (parentPath) {
+      const parentKey = this._pathToKey(parentPath);
+      const parentRow = this.getStmt.get(parentKey);
+      if (parentRow) {
+        const parentValue = JSON.parse(parentRow.value);
+        const relativePath = args.slice(parentPath.length);
+        return this._getFromObject(parentValue, relativePath);
+      }
+    }
+    
+    return null;
+  }
+  
+  async set(...args) {
+    if (args.length === 0) {
+      throw new Error('set() requires at least one argument');
+    }
+    
+    if (args.length === 1) {
+      // Setting root object
+      await this._setRootObject(args[0]);
+      return [];
+    }
+    
+    const keys = args.slice(0, -1);
+    const value = args[args.length - 1];
+    const key = this._pathToKey(keys);
+    
+    // Check if any parent path exists as an object that needs to be expanded
+    this._expandParentObjects(keys);
+    
+    this.setStmt.run(key, JSON.stringify(value));
+    return keys;
+  }
+  
+  async del(...keys) {
+    if (keys.length === 0) {
+      // Delete everything
+      this.db.exec('DELETE FROM deepbase');
+      return;
+    }
+    
+    const key = this._pathToKey(keys);
+    
+    // Delete the key itself
+    this.delStmt.run(key);
+    
+    // Delete all children
+    const childKey = key + '.';
+    this.db.prepare('DELETE FROM deepbase WHERE key LIKE ?').run(childKey + '%');
+  }
+  
+  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) {
+    const value = keys.pop();
+    const id = this.nanoid();
+    await this.set(...[...keys, id], value);
+    return [...keys, id];
+  }
+  
+  async upd(...args) {
+    const func = args.pop();
+    return this.set(...args, func(await this.get(...args)));
+  }
+  
+  _pathToKey(path) {
+    return path.join('.');
+  }
+  
+  _keyToPath(key) {
+    return key.split('.');
+  }
+  
+  _getRootObject() {
+    const rows = this.getAllStmt.all();
+    const result = {};
+    
+    for (const row of rows) {
+      const path = this._keyToPath(row.key);
+      const value = JSON.parse(row.value);
+      this._setNestedValue(result, path, value);
+    }
+    
+    return result;
+  }
+  
+  async _setRootObject(obj) {
+    // Clear existing data
+    this.db.exec('DELETE FROM deepbase');
+    
+    // Flatten and insert
+    const entries = this._flattenObject(obj);
+    const insertMany = this.db.transaction((entries) => {
+      for (const [key, value] of entries) {
+        this.setStmt.run(key, JSON.stringify(value));
+      }
+    });
+    
+    insertMany(entries);
+  }
+  
+  _buildObjectFromChildren(parentKey) {
+    const prefix = parentKey ? parentKey + '.' : '';
+    const rows = this.getKeysLikeStmt.all(prefix + '%');
+    const result = {};
+    
+    for (const row of rows) {
+      const fullPath = this._keyToPath(row.key);
+      const relativePath = parentKey 
+        ? fullPath.slice(this._keyToPath(parentKey).length)
+        : fullPath;
+      
+      const value = JSON.parse(row.value);
+      this._setNestedValue(result, relativePath, value);
+    }
+    
+    return result;
+  }
+  
+  _setNestedValue(obj, path, value) {
+    if (path.length === 1) {
+      obj[path[0]] = value;
+      return;
+    }
+    
+    const key = path[0];
+    if (!obj.hasOwnProperty(key) || typeof obj[key] !== "object") {
+      obj[key] = {};
+    }
+    
+    this._setNestedValue(obj[key], path.slice(1), value);
+  }
+  
+  _flattenObject(obj, prefix = '') {
+    const entries = [];
+    
+    for (const [key, value] of Object.entries(obj)) {
+      const fullKey = prefix ? `${prefix}.${key}` : key;
+      
+      if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+        entries.push(...this._flattenObject(value, fullKey));
+      } else {
+        entries.push([fullKey, value]);
+      }
+    }
+    
+    return entries;
+  }
+  
+  _findParentWithValue(path) {
+    // Try to find a parent path that has a stored value
+    // For example: if looking for ['users', 'abc', 'name']
+    // and 'users.abc' exists as a stored JSON object, return ['users', 'abc']
+    for (let i = path.length - 1; i > 0; i--) {
+      const parentPath = path.slice(0, i);
+      const parentKey = this._pathToKey(parentPath);
+      const row = this.getStmt.get(parentKey);
+      if (row) {
+        const value = JSON.parse(row.value);
+        // Only return if it's an object (not a primitive)
+        if (value !== null && typeof value === 'object') {
+          return parentPath;
+        }
+      }
+    }
+    return null;
+  }
+  
+  _getFromObject(obj, path) {
+    if (path.length === 0) return obj;
+    if (path.length === 1) {
+      return obj === null || obj[path[0]] === undefined ? null : obj[path[0]];
+    }
+    
+    const key = path[0];
+    if (!obj.hasOwnProperty(key)) return null;
+    
+    return this._getFromObject(obj[key], path.slice(1));
+  }
+  
+  _expandParentObjects(path) {
+    // Check each parent level (not including the path itself) to see if it exists as an object that needs expanding
+    // For example, if path is ['config', 'theme'], check if 'config' exists as an object
+    for (let i = 1; i < path.length; i++) {
+      const parentPath = path.slice(0, i);
+      const parentKey = this._pathToKey(parentPath);
+      const parentRow = this.getStmt.get(parentKey);
+      
+      if (parentRow) {
+        const parentValue = JSON.parse(parentRow.value);
+        
+        // If it's an object (not array or primitive), expand it
+        if (parentValue !== null && typeof parentValue === 'object' && !Array.isArray(parentValue)) {
+          // Delete the parent key
+          this.delStmt.run(parentKey);
+          
+          // Insert all properties as individual keys
+          const entries = this._flattenObject(parentValue, parentKey);
+          for (const [key, value] of entries) {
+            this.setStmt.run(key, JSON.stringify(value));
+          }
+        }
+      }
+    }
+  }
+}
+
+export default SqliteDriver;
+
+

package/src/index.js

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

package/test/test.js

@@ -0,0 +1,446 @@
+import assert from 'assert';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { DeepBase } from '../../core/src/index.js';
+import { SqliteDriver } from '../src/SqliteDriver.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const testDataPath = path.join(__dirname, 'test-data');
+
+describe('SqliteDriver', function() {
+  let db;
+  let testCounter = 0;
+
+  before(function() {
+    // Clean up test data before all tests
+    if (fs.existsSync(testDataPath)) {
+      fs.rmSync(testDataPath, { recursive: true, force: true });
+    }
+  });
+
+  beforeEach(async function() {
+    // Use unique name for each test to avoid singleton conflicts
+    testCounter++;
+    db = new DeepBase(new SqliteDriver({ 
+      name: `test-${testCounter}`, 
+      path: testDataPath 
+    }));
+    await db.connect();
+  });
+
+  afterEach(async function() {
+    await db.disconnect();
+    if (fs.existsSync(testDataPath)) {
+      fs.rmSync(testDataPath, { recursive: true, force: true });
+    }
+  });
+
+  describe('Basic Operations', function() {
+    it('should set and get a simple value', async function() {
+      await db.set('key', 'value');
+      const result = await db.get('key');
+      assert.strictEqual(result, 'value');
+    });
+
+    it('should set and get nested values', async function() {
+      await db.set('user', 'name', 'Alice');
+      await db.set('user', 'age', 30);
+      
+      const name = await db.get('user', 'name');
+      const age = await db.get('user', 'age');
+      
+      assert.strictEqual(name, 'Alice');
+      assert.strictEqual(age, 30);
+    });
+
+    it('should get entire nested object', async function() {
+      await db.set('user', 'name', 'Bob');
+      await db.set('user', 'age', 25);
+      
+      const user = await db.get('user');
+      assert.deepStrictEqual(user, { name: 'Bob', age: 25 });
+    });
+
+    it('should return null for non-existent keys', async function() {
+      const result = await db.get('nonexistent');
+      assert.strictEqual(result, null);
+    });
+
+    it('should handle numbers', async function() {
+      await db.set('number', 42);
+      const result = await db.get('number');
+      assert.strictEqual(result, 42);
+    });
+
+    it('should handle booleans', async function() {
+      await db.set('flag', true);
+      const result = await db.get('flag');
+      assert.strictEqual(result, true);
+    });
+
+    it('should handle arrays', async function() {
+      await db.set('list', [1, 2, 3]);
+      const result = await db.get('list');
+      assert.deepStrictEqual(result, [1, 2, 3]);
+    });
+
+    it('should handle complex objects', async function() {
+      const complexObj = {
+        name: 'Test',
+        items: [1, 2, 3],
+        meta: { created: '2024-01-01', active: true }
+      };
+      await db.set('complex', complexObj);
+      const result = await db.get('complex');
+      assert.deepStrictEqual(result, complexObj);
+    });
+  });
+
+  describe('Delete Operations', function() {
+    it('should delete a key', async function() {
+      await db.set('temp', 'value');
+      await db.del('temp');
+      
+      const result = await db.get('temp');
+      assert.strictEqual(result, null);
+    });
+
+    it('should delete nested key', async function() {
+      await db.set('user', 'name', 'Alice');
+      await db.set('user', 'age', 30);
+      await db.del('user', 'age');
+      
+      const user = await db.get('user');
+      assert.deepStrictEqual(user, { name: 'Alice' });
+    });
+
+    it('should delete parent and all children', async function() {
+      await db.set('parent', 'child1', 'value1');
+      await db.set('parent', 'child2', 'value2');
+      await db.set('parent', 'nested', 'deep', 'value3');
+      
+      await db.del('parent');
+      
+      const result = await db.get('parent');
+      assert.strictEqual(result, null);
+      
+      const child1 = await db.get('parent', 'child1');
+      assert.strictEqual(child1, null);
+      
+      const nested = await db.get('parent', 'nested', 'deep');
+      assert.strictEqual(nested, null);
+    });
+
+    it('should clear all data', async function() {
+      await db.set('key1', 'value1');
+      await db.set('key2', 'value2');
+      await db.del();
+      
+      const all = await db.get();
+      assert.deepStrictEqual(all, {});
+    });
+  });
+
+  describe('Add Operation', function() {
+    it('should add item with auto-generated ID', async function() {
+      const path = await db.add('users', { name: 'Charlie' });
+      
+      assert.strictEqual(path.length, 2);
+      assert.strictEqual(path[0], 'users');
+      assert.strictEqual(typeof path[1], 'string');
+      assert.strictEqual(path[1].length, 10);
+      
+      const user = await db.get(...path);
+      assert.deepStrictEqual(user, { name: 'Charlie' });
+    });
+
+    it('should add multiple items with unique IDs', async function() {
+      const path1 = await db.add('items', { value: 1 });
+      const path2 = await db.add('items', { value: 2 });
+      
+      assert.notStrictEqual(path1[1], path2[1]);
+      
+      const item1 = await db.get(...path1);
+      const item2 = await db.get(...path2);
+      
+      assert.deepStrictEqual(item1, { value: 1 });
+      assert.deepStrictEqual(item2, { value: 2 });
+    });
+
+    it('should add items at nested paths', async function() {
+      const path = await db.add('categories', 'electronics', 'items', { name: 'Laptop' });
+      
+      assert.strictEqual(path.length, 4);
+      assert.strictEqual(path[0], 'categories');
+      assert.strictEqual(path[1], 'electronics');
+      assert.strictEqual(path[2], 'items');
+      
+      const item = await db.get(...path);
+      assert.deepStrictEqual(item, { name: 'Laptop' });
+    });
+  });
+
+  describe('Increment/Decrement', function() {
+    it('should increment a value', async function() {
+      await db.set('counter', 10);
+      await db.inc('counter', 5);
+      
+      const result = await db.get('counter');
+      assert.strictEqual(result, 15);
+    });
+
+    it('should decrement a value', async function() {
+      await db.set('counter', 20);
+      await db.dec('counter', 8);
+      
+      const result = await db.get('counter');
+      assert.strictEqual(result, 12);
+    });
+
+    it('should increment nested value', async function() {
+      await db.set('user', 'balance', 100);
+      await db.inc('user', 'balance', 50);
+      
+      const balance = await db.get('user', 'balance');
+      assert.strictEqual(balance, 150);
+    });
+
+    it('should handle negative increments', async function() {
+      await db.set('counter', 10);
+      await db.inc('counter', -3);
+      
+      const result = await db.get('counter');
+      assert.strictEqual(result, 7);
+    });
+  });
+
+  describe('Update Operation', function() {
+    it('should update value with function', async function() {
+      await db.set('name', 'alice');
+      await db.upd('name', name => name.toUpperCase());
+      
+      const result = await db.get('name');
+      assert.strictEqual(result, 'ALICE');
+    });
+
+    it('should update nested value with function', async function() {
+      await db.set('user', 'age', 25);
+      await db.upd('user', 'age', age => age + 1);
+      
+      const age = await db.get('user', 'age');
+      assert.strictEqual(age, 26);
+    });
+
+    it('should update object with function', async function() {
+      await db.set('user', { name: 'Alice', age: 30 });
+      await db.upd('user', user => ({ ...user, age: user.age + 1 }));
+      
+      const user = await db.get('user');
+      assert.deepStrictEqual(user, { name: 'Alice', age: 31 });
+    });
+  });
+
+  describe('Keys, Values, Entries', function() {
+    beforeEach(async function() {
+      await db.set('users', 'alice', { age: 30 });
+      await db.set('users', 'bob', { age: 25 });
+    });
+
+    it('should get keys', async function() {
+      const keys = await db.keys('users');
+      assert.deepStrictEqual(keys.sort(), ['alice', 'bob']);
+    });
+
+    it('should get values', async function() {
+      const values = await db.values('users');
+      assert.strictEqual(values.length, 2);
+      assert.ok(values.some(v => v.age === 30));
+      assert.ok(values.some(v => v.age === 25));
+    });
+
+    it('should get entries', async function() {
+      const entries = await db.entries('users');
+      assert.strictEqual(entries.length, 2);
+      assert.ok(entries.some(([k, v]) => k === 'alice' && v.age === 30));
+      assert.ok(entries.some(([k, v]) => k === 'bob' && v.age === 25));
+    });
+
+    it('should return empty arrays for non-object values', async function() {
+      await db.set('simple', 'string');
+      
+      const keys = await db.keys('simple');
+      const values = await db.values('simple');
+      const entries = await db.entries('simple');
+      
+      assert.deepStrictEqual(keys, []);
+      assert.deepStrictEqual(values, []);
+      assert.deepStrictEqual(entries, []);
+    });
+  });
+
+  describe('Persistence', function() {
+    it('should persist data to database file', async function() {
+      // Use a separate db for this test
+      const persistDb = new DeepBase(new SqliteDriver({ 
+        name: 'persist-test', 
+        path: testDataPath 
+      }));
+      await persistDb.connect();
+      await persistDb.set('persistent', 'data');
+      await persistDb.disconnect();
+      
+      const filePath = path.join(testDataPath, 'persist-test.db');
+      assert.ok(fs.existsSync(filePath));
+    });
+
+    it('should load existing data on connect', async function() {
+      // Use a separate db for this test
+      const db1 = new DeepBase(new SqliteDriver({ 
+        name: 'reload-test', 
+        path: testDataPath 
+      }));
+      await db1.connect();
+      await db1.set('existing', 'value');
+      await db1.set('nested', 'key', 'data');
+      await db1.disconnect();
+      
+      // Create new instance pointing to same file
+      const db2 = new DeepBase(new SqliteDriver({ 
+        name: 'reload-test', 
+        path: testDataPath 
+      }));
+      await db2.connect();
+      
+      const result = await db2.get('existing');
+      assert.strictEqual(result, 'value');
+      
+      const nested = await db2.get('nested', 'key');
+      assert.strictEqual(nested, 'data');
+      
+      await db2.disconnect();
+    });
+
+    it('should handle reconnection', async function() {
+      await db.set('before', 'disconnect');
+      await db.disconnect();
+      
+      await db.connect();
+      const result = await db.get('before');
+      assert.strictEqual(result, 'disconnect');
+    });
+  });
+
+  describe('Singleton Pattern', function() {
+    it('should return same instance for same file', function() {
+      const driver1 = new SqliteDriver({ name: 'singleton', path: testDataPath });
+      const driver2 = new SqliteDriver({ name: 'singleton', path: testDataPath });
+      
+      assert.strictEqual(driver1, driver2);
+    });
+
+    it('should return different instances for different files', function() {
+      const driver1 = new SqliteDriver({ name: 'file1', path: testDataPath });
+      const driver2 = new SqliteDriver({ name: 'file2', path: testDataPath });
+      
+      assert.notStrictEqual(driver1, driver2);
+    });
+  });
+
+  describe('Root Object Operations', function() {
+    it('should set entire root object', async function() {
+      const data = {
+        users: { alice: { age: 30 }, bob: { age: 25 } },
+        config: { theme: 'dark', lang: 'en' }
+      };
+      
+      await db.set(data);
+      const result = await db.get();
+      assert.deepStrictEqual(result, data);
+    });
+
+    it('should get entire root object', async function() {
+      await db.set('key1', 'value1');
+      await db.set('key2', 'value2');
+      await db.set('nested', 'key', 'value');
+      
+      const result = await db.get();
+      assert.deepStrictEqual(result, {
+        key1: 'value1',
+        key2: 'value2',
+        nested: { key: 'value' }
+      });
+    });
+
+    it('should replace root object on set', async function() {
+      await db.set('old', 'data');
+      
+      const newData = { new: 'data' };
+      await db.set(newData);
+      
+      const result = await db.get();
+      assert.deepStrictEqual(result, newData);
+      
+      const old = await db.get('old');
+      assert.strictEqual(old, null);
+    });
+  });
+
+  describe('Deep Nesting', function() {
+    it('should handle deeply nested paths', async function() {
+      await db.set('a', 'b', 'c', 'd', 'e', 'deep value');
+      const result = await db.get('a', 'b', 'c', 'd', 'e');
+      assert.strictEqual(result, 'deep value');
+    });
+
+    it('should get partial deep objects', async function() {
+      await db.set('a', 'b', 'c', 'value1');
+      await db.set('a', 'b', 'd', 'value2');
+      await db.set('a', 'e', 'value3');
+      
+      const resultB = await db.get('a', 'b');
+      assert.deepStrictEqual(resultB, { c: 'value1', d: 'value2' });
+      
+      const resultA = await db.get('a');
+      assert.deepStrictEqual(resultA, {
+        b: { c: 'value1', d: 'value2' },
+        e: 'value3'
+      });
+    });
+  });
+
+  describe('Overwriting Object with Nested Properties', function() {
+    it('should handle setting object first then nested properties', async function() {
+      // This is the scenario from example 05-sqlite.js
+      await db.set('config', { lang: 'en', theme: 'dark' });
+      await db.set('config', 'lang', 'en');
+      await db.set('config', 'theme', 'light');
+      
+      const config = await db.get('config');
+      assert.deepStrictEqual(config, { lang: 'en', theme: 'light' });
+    });
+
+    it('should prioritize nested properties over initial object', async function() {
+      await db.set('settings', { a: 1, b: 2, c: 3 });
+      await db.set('settings', 'b', 99);
+      await db.set('settings', 'd', 4);
+      
+      const settings = await db.get('settings');
+      assert.deepStrictEqual(settings, { a: 1, b: 99, c: 3, d: 4 });
+    });
+
+    it('should handle nested object then deeper nesting', async function() {
+      await db.set('user', { name: 'Alice', meta: { role: 'admin' } });
+      await db.set('user', 'meta', 'role', 'user');
+      await db.set('user', 'meta', 'active', true);
+      
+      const user = await db.get('user');
+      assert.deepStrictEqual(user, { 
+        name: 'Alice', 
+        meta: { role: 'user', active: true } 
+      });
+    });
+  });
+});
+
+