deepbase-sqlite 3.8.6 → 3.9.0

package/README.md

@@ -28,10 +28,13 @@ Stores data in SQLite database files. Perfect for:
 
 ```javascript
 import DeepBase from 'deepbase';
+import { resolvePath } from 'deepbase/path';
 import SqliteDriver from 'deepbase-sqlite';
 
+const dataPath = resolvePath(import.meta.url, './data');
+
 const db = new DeepBase(new SqliteDriver({
-  path: './data',
+  path: dataPath,
   name: 'mydb',
   pragma: 'balanced' // default — omit for same result
 }));
@@ -42,11 +45,15 @@ await db.set('users', 'alice', { name: 'Alice', age: 30 });
 const alice = await db.get('users', 'alice');
 ```
 
+`path` is required and must be absolute. `resolvePath()` anchors a relative
+path to your application module instead of `process.cwd()` or the installed
+package location.
+
 ## Options
 
 ```javascript
 new SqliteDriver({
-  path: './data',              // Directory to store database files
+  path: '/var/lib/myapp/data', // Required absolute directory for database files
   name: 'default',            // Database filename (without .db)
   pragma: 'balanced',         // Performance profile: 'none' | 'safe' | 'balanced' | 'fast'
   busyTimeoutMs: 5000,        // Native wait per lock attempt
@@ -75,8 +82,8 @@ Uses `better-sqlite3` for synchronous operations wrapped in async API:
 Multiple instances and same-host processes may safely point to the same database file. Each driver owns its connection and lifecycle; SQLite coordinates writers using WAL, `BEGIN IMMEDIATE`, a busy timeout, and bounded transaction retries:
 
 ```javascript
-const db1 = new DeepBase(new SqliteDriver({ name: 'mydb' }));
-const db2 = new DeepBase(new SqliteDriver({ name: 'mydb' }));
+const db1 = new DeepBase(new SqliteDriver({ path: '/var/lib/myapp/data', name: 'mydb' }));
+const db2 = new DeepBase(new SqliteDriver({ path: '/var/lib/myapp/data', name: 'mydb' }));
 // Independent connections; disconnecting db1 does not close db2.
 ```
 
@@ -160,16 +167,16 @@ All WAL modes use `journal_mode=WAL` and `temp_store=MEMORY`. Lock waiting is co
 
 ```javascript
 // Backward-compatible (no PRAGMAs, no WITHOUT ROWID)
-new SqliteDriver({ name: 'mydb', pragma: 'none' })
+new SqliteDriver({ path: '/var/lib/myapp/data', name: 'mydb', pragma: 'none' })
 
 // Maximum durability
-new SqliteDriver({ name: 'mydb', pragma: 'safe' })
+new SqliteDriver({ path: '/var/lib/myapp/data', name: 'mydb', pragma: 'safe' })
 
 // Recommended (default)
-new SqliteDriver({ name: 'mydb', pragma: 'balanced' })
+new SqliteDriver({ path: '/var/lib/myapp/data', name: 'mydb', pragma: 'balanced' })
 
 // Maximum throughput
-new SqliteDriver({ name: 'mydb', pragma: 'fast' })
+new SqliteDriver({ path: '/var/lib/myapp/data', name: 'mydb', pragma: 'fast' })
 ```
 
 `SqliteFastDriver` is kept as a named alias for backward compatibility:
@@ -237,7 +244,7 @@ import SqliteDriver from 'deepbase-sqlite';
 import MongoDriver from 'deepbase-mongodb';
 
 const db = new DeepBase([
-  new SqliteDriver({ path: './data' }),
+  new SqliteDriver({ path: '/var/lib/myapp/data' }),
   new MongoDriver({ url: 'mongodb://localhost:27017' })
 ]);
 
@@ -379,5 +386,3 @@ Notes:
 ## License
 
 MIT - Copyright (c) Martin Clasen
-
-

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepbase-sqlite",
-  "version": "3.8.6",
+  "version": "3.9.0",
   "description": "⚡ DeepBase SQLite - SQLite database driver",
   "type": "module",
   "main": "src/index.cjs",
@@ -17,7 +17,7 @@
     "better-sqlite3": "^11.8.1"
   },
   "peerDependencies": {
-    "deepbase": "^3.8.6"
+    "deepbase": "^3.9.0"
   },
   "devDependencies": {
     "mocha": "^10.8.2"

package/src/SqliteDriver.js

@@ -11,9 +11,13 @@ export class SqliteDriver extends DeepBaseDriver {
   constructor({ name, path, pragma, busyTimeoutMs, busyRetry, ...opts } = {}) {
     super(opts);
 
+    if (typeof path !== 'string' || path.trim() === '' || !pathModule.isAbsolute(path)) {
+      throw new TypeError('SqliteDriver requires an absolute "path" option.');
+    }
+
     const config = resolveSqliteConfig({ pragma, busyTimeoutMs, busyRetry });
     this.name = name || 'default';
-    this.path = path || pathModule.join(process.cwd(), 'db');
+    this.path = path;
     this.pragma = config.pragma;
     this.pragmaConfig = config.pragmaConfig;
     this.busyTimeoutMs = config.busyTimeoutMs;

package/src/index.d.ts

@@ -19,14 +19,15 @@ export interface SqliteCheckpointResult {
 
 export interface SqliteDriverOptions extends DeepBaseDriverOptions {
     name?: string;
-    path?: string;
+    /** Required absolute storage directory. */
+    path: string;
     pragma?: 'none' | 'safe' | 'balanced' | 'fast';
     busyTimeoutMs?: number;
     busyRetry?: SqliteBusyRetryOptions;
 }
 
 export class SqliteDriver extends DeepBaseDriver {
-    constructor(options?: SqliteDriverOptions);
+    constructor(options: SqliteDriverOptions);
 
     name: string;
     path: string;

package/test/test-multiprocess.js

@@ -68,15 +68,15 @@ describe('SqliteDriver multi-process safety', function () {
 
   it('validates concurrency options eagerly', function () {
     assert.throws(
-      () => new SqliteDriver({ pragma: 'invalid' }),
+      () => new SqliteDriver({ path: testDataPath, pragma: 'invalid' }),
       /pragma must be one of/,
     );
     assert.throws(
-      () => new SqliteDriver({ busyTimeoutMs: -1 }),
+      () => new SqliteDriver({ path: testDataPath, busyTimeoutMs: -1 }),
       /busyTimeoutMs must be a non-negative integer/,
     );
     assert.throws(
-      () => new SqliteDriver({ busyRetry: { maxAttempts: 0 } }),
+      () => new SqliteDriver({ path: testDataPath, busyRetry: { maxAttempts: 0 } }),
       /maxAttempts must be at least 1/,
     );
   });

package/test/test.js

@@ -11,6 +11,19 @@ const testDataPath = path.join(__dirname, 'test-data');
 
 const PRAGMA_MODES = ['none', 'safe', 'balanced', 'fast'];
 
+describe('SqliteDriver configuration', function () {
+  it('should require an absolute storage path', function () {
+    assert.throws(
+      () => new SqliteDriver({ name: 'missing-path' }),
+      /requires an absolute "path" option/,
+    );
+    assert.throws(
+      () => new SqliteDriver({ name: 'relative-path', path: './data' }),
+      /requires an absolute "path" option/,
+    );
+  });
+});
+
 for (const pragma of PRAGMA_MODES) {
   describe(`SqliteDriver [pragma=${pragma}]`, function () {
     let db;