bun-sqlite-for-rxdb 1.0.1

package/src/cleanup.test.ts

@@ -0,0 +1,110 @@
+import { describe, test, expect, afterEach } from 'bun:test';
+import { BunSQLiteStorageInstance } from './instance';
+import type { RxStorageInstanceCreationParams } from 'rxdb';
+
+describe('cleanup() - TDD Red Phase', () => {
+	const instances: BunSQLiteStorageInstance<any>[] = [];
+
+	afterEach(async () => {
+		for (const instance of instances) {
+			await instance.close();
+		}
+		instances.length = 0;
+	});
+
+	test('cleanup() should return false when documents are deleted', async () => {
+		const instance = new BunSQLiteStorageInstance({
+			databaseName: 'testdb',
+			collectionName: 'users',
+			databaseInstanceToken: 'test',
+			schema: {
+				version: 0,
+				primaryKey: 'id',
+				type: 'object',
+				properties: { id: { type: 'string' } }
+			},
+			options: {},
+			devMode: false,
+			multiInstance: false,
+			internals: {}
+		} as RxStorageInstanceCreationParams<any, any>);
+		instances.push(instance);
+
+		const doc = {
+			id: 'doc1',
+			_deleted: false,
+			_attachments: {},
+			_meta: { lwt: Date.now() },
+			_rev: '1-abc'
+		};
+
+		await instance.bulkWrite([{ document: doc }], 'test');
+
+		const deletedDoc = { ...doc, _deleted: true, _rev: '2-def', _meta: { lwt: Date.now() } };
+		await instance.bulkWrite([{ previous: doc, document: deletedDoc }], 'test');
+
+		const result = await instance.cleanup(Date.now() + 1000);
+		
+		expect(result).toBe(false);
+	});
+
+	test('cleanup() should return true when no documents to clean', async () => {
+		const instance = new BunSQLiteStorageInstance({
+			databaseName: 'testdb',
+			collectionName: 'users',
+			databaseInstanceToken: 'test',
+			schema: {
+				version: 0,
+				primaryKey: 'id',
+				type: 'object',
+				properties: { id: { type: 'string' } }
+			},
+			options: {},
+			devMode: false,
+			multiInstance: false,
+			internals: {}
+		} as RxStorageInstanceCreationParams<any, any>);
+		instances.push(instance);
+
+		const result = await instance.cleanup(0);
+		
+		expect(result).toBe(true);
+	});
+
+	test('cleanup() should actually remove deleted documents', async () => {
+		const instance = new BunSQLiteStorageInstance({
+			databaseName: 'testdb',
+			collectionName: 'users',
+			databaseInstanceToken: 'test',
+			schema: {
+				version: 0,
+				primaryKey: 'id',
+				type: 'object',
+				properties: { id: { type: 'string' } }
+			},
+			options: {},
+			devMode: false,
+			multiInstance: false,
+			internals: {}
+		} as RxStorageInstanceCreationParams<any, any>);
+		instances.push(instance);
+
+		const doc = {
+			id: 'doc1',
+			_deleted: false,
+			_attachments: {},
+			_meta: { lwt: Date.now() },
+			_rev: '1-abc'
+		};
+
+		await instance.bulkWrite([{ document: doc }], 'test');
+
+		const deletedDoc = { ...doc, _deleted: true, _rev: '2-def', _meta: { lwt: Date.now() } };
+		await instance.bulkWrite([{ previous: doc, document: deletedDoc }], 'test');
+
+		await instance.cleanup(Date.now() + 1000);
+
+		const found = await instance.findDocumentsById(['doc1'], true);
+		expect(found.length).toBe(0);
+	});
+});

package/src/collection-isolation.test.ts

@@ -0,0 +1,74 @@
+import { describe, it, expect } from 'bun:test';
+import { createRxDatabase, addRxPlugin } from 'rxdb';
+import { RxDBDevModePlugin } from 'rxdb/plugins/dev-mode';
+import { wrappedValidateAjvStorage } from 'rxdb/plugins/validate-ajv';
+import { getRxStorageBunSQLite } from './index';
+
+addRxPlugin(RxDBDevModePlugin);
+
+describe('Collection Isolation', () => {
+  it('should NOT leak events across different collections in same database', async () => {
+    const dbName = 'test-collection-isolation-' + Date.now();
+    
+    const db = await createRxDatabase({
+      name: dbName,
+      storage: wrappedValidateAjvStorage({ storage: getRxStorageBunSQLite() }),
+      multiInstance: true,
+      ignoreDuplicate: true
+    });
+
+    await db.addCollections({
+      users: {
+        schema: {
+          version: 0,
+          primaryKey: 'id',
+          type: 'object',
+          properties: {
+            id: { type: 'string', maxLength: 100 },
+            name: { type: 'string' }
+          },
+          required: ['id', 'name']
+        }
+      },
+      posts: {
+        schema: {
+          version: 0,
+          primaryKey: 'id',
+          type: 'object',
+          properties: {
+            id: { type: 'string', maxLength: 100 },
+            title: { type: 'string' }
+          },
+          required: ['id', 'title']
+        }
+      }
+    });
+
+    let usersChangeCount = 0;
+    let postsChangeCount = 0;
+
+    const usersSub = db.users.find().$.subscribe(() => {
+      usersChangeCount++;
+    });
+
+    const postsSub = db.posts.find().$.subscribe(() => {
+      postsChangeCount++;
+    });
+
+    await new Promise(resolve => setTimeout(resolve, 100));
+    
+    const initialUsersCount = usersChangeCount;
+    const initialPostsCount = postsChangeCount;
+
+    await db.posts.insert({ id: 'post1', title: 'Hello World' });
+    
+    await new Promise(resolve => setTimeout(resolve, 100));
+
+    expect(postsChangeCount).toBeGreaterThan(initialPostsCount);
+    expect(usersChangeCount).toBe(initialUsersCount);
+
+    usersSub.unsubscribe();
+    postsSub.unsubscribe();
+    await db.remove();
+  });
+});

package/src/connection-pool.test.ts

@@ -0,0 +1,102 @@
+import { describe, test, expect, afterEach } from 'bun:test';
+import { getDatabase, releaseDatabase } from './connection-pool';
+
+describe('Connection Pool', () => {
+	afterEach(() => {
+		// Clean up any leaked connections
+		const leaked = ['testdb1', 'testdb2', 'testdb3'];
+		leaked.forEach(name => {
+			try { releaseDatabase(name); } catch {}
+		});
+	});
+
+	test('should share Database object for same databaseName', () => {
+		const db1 = getDatabase('testdb1', ':memory:');
+		const db2 = getDatabase('testdb1', ':memory:');
+		
+		expect(db1).toBe(db2); // Same object reference
+		
+		releaseDatabase('testdb1');
+		releaseDatabase('testdb1');
+	});
+
+	test('should create separate Database objects for different databaseNames', () => {
+		const db1 = getDatabase('testdb1', ':memory:');
+		const db2 = getDatabase('testdb2', ':memory:');
+		
+		expect(db1).not.toBe(db2); // Different objects
+		
+		releaseDatabase('testdb1');
+		releaseDatabase('testdb2');
+	});
+
+	test('should throw error when same databaseName used with different filenames', () => {
+		getDatabase('testdb1', ':memory:');
+		
+		expect(() => {
+			getDatabase('testdb1', './different.db');
+		}).toThrow("Database 'testdb1' already opened with different filename");
+		
+		releaseDatabase('testdb1');
+	});
+
+	test('should increment reference count on multiple getDatabase calls', () => {
+		const db1 = getDatabase('testdb1', ':memory:');
+		const db2 = getDatabase('testdb1', ':memory:');
+		const db3 = getDatabase('testdb1', ':memory:');
+		
+		expect(db1).toBe(db2);
+		expect(db2).toBe(db3);
+		
+		// Create a table to verify database stays open
+		db1.run('CREATE TABLE test (id INTEGER)');
+		
+		// Release twice - should still be open
+		releaseDatabase('testdb1');
+		releaseDatabase('testdb1');
+		
+		// Database should still work
+		expect(() => db1.run('INSERT INTO test VALUES (1)')).not.toThrow();
+		
+		// Final release - now it closes
+		releaseDatabase('testdb1');
+	});
+
+	test('should close database when reference count reaches zero', () => {
+		const db = getDatabase('testdb1', ':memory:');
+		db.run('CREATE TABLE test (id INTEGER)');
+		
+		releaseDatabase('testdb1');
+		
+		// Database should be closed now
+		expect(() => db.run('INSERT INTO test VALUES (1)')).toThrow();
+	});
+
+	test('should handle multiple databases independently', () => {
+		const db1 = getDatabase('testdb1', ':memory:');
+		const db2 = getDatabase('testdb2', ':memory:');
+		
+		db1.run('CREATE TABLE test1 (id INTEGER)');
+		db2.run('CREATE TABLE test2 (id INTEGER)');
+		
+		// Close db1
+		releaseDatabase('testdb1');
+		expect(() => db1.run('INSERT INTO test1 VALUES (1)')).toThrow();
+		
+		// db2 should still work
+		expect(() => db2.run('INSERT INTO test2 VALUES (1)')).not.toThrow();
+		
+		releaseDatabase('testdb2');
+	});
+
+	test('should allow reusing databaseName after full release', () => {
+		const db1 = getDatabase('testdb1', ':memory:');
+		releaseDatabase('testdb1');
+		
+		// Should be able to get a new database with same name
+		const db2 = getDatabase('testdb1', ':memory:');
+		expect(db2).not.toBe(db1); // Different instance (old one was closed)
+		
+		releaseDatabase('testdb1');
+	});
+});

package/src/connection-pool.ts

@@ -0,0 +1,38 @@
+import { Database } from 'bun:sqlite';
+
+type DatabaseState = {
+	db: Database;
+	filename: string;
+	openConnections: number;
+};
+
+const DATABASE_POOL = new Map<string, DatabaseState>();
+
+export function getDatabase(databaseName: string, filename: string): Database {
+	let state = DATABASE_POOL.get(databaseName);
+	if (!state) {
+		state = {
+			db: new Database(filename),
+			filename,
+			openConnections: 1
+		};
+		DATABASE_POOL.set(databaseName, state);
+	} else {
+		if (state.filename !== filename) {
+			throw new Error(`Database '${databaseName}' already opened with different filename: '${state.filename}' vs '${filename}'`);
+		}
+		state.openConnections++;
+	}
+	return state.db;
+}
+
+export function releaseDatabase(databaseName: string): void {
+	const state = DATABASE_POOL.get(databaseName);
+	if (state) {
+		state.openConnections--;
+		if (state.openConnections === 0) {
+			state.db.close();
+			DATABASE_POOL.delete(databaseName);
+		}
+	}
+}

package/src/findDocumentsById.test.ts

@@ -0,0 +1,122 @@
+import { describe, expect, test } from 'bun:test';
+import { getRxStorageBunSQLite } from './storage';
+import type { RxDocumentData, RxJsonSchema } from 'rxdb';
+
+interface TestDoc {
+	id: string;
+	name: string;
+	age: number;
+	_deleted: boolean;
+	_attachments: {};
+	_rev: string;
+	_meta: { lwt: number };
+}
+
+const testSchema: RxJsonSchema<RxDocumentData<TestDoc>> = {
+	version: 0,
+	primaryKey: 'id',
+	type: 'object',
+	properties: {
+		id: { type: 'string', maxLength: 100 },
+		name: { type: 'string' },
+		age: { type: 'number' },
+		_deleted: { type: 'boolean' },
+		_attachments: { type: 'object' },
+		_rev: { type: 'string' },
+		_meta: {
+			type: 'object',
+			properties: {
+				lwt: { type: 'number' }
+			},
+			required: ['lwt']
+		}
+	},
+	required: ['id', '_deleted', '_rev', '_meta']
+};
+
+describe('findDocumentsById - withDeleted semantics', () => {
+	test('withDeleted=false returns ONLY non-deleted docs', async () => {
+		const storage = getRxStorageBunSQLite();
+		const instance = await storage.createStorageInstance({
+			databaseName: 'test-db',
+			collectionName: 'test-collection',
+			schema: testSchema,
+			options: {},
+			multiInstance: false,
+			devMode: false,
+			databaseInstanceToken: 'test-token'
+		});
+
+		const docs: RxDocumentData<TestDoc>[] = [
+			{ id: 'doc1', name: 'Active', age: 25, _deleted: false, _attachments: {}, _rev: '1-a', _meta: { lwt: Date.now() } },
+			{ id: 'doc2', name: 'Deleted', age: 30, _deleted: true, _attachments: {}, _rev: '1-b', _meta: { lwt: Date.now() } },
+			{ id: 'doc3', name: 'Active2', age: 35, _deleted: false, _attachments: {}, _rev: '1-c', _meta: { lwt: Date.now() } }
+		];
+
+		await instance.bulkWrite(docs.map(doc => ({ document: doc })), 'test');
+
+		const result = await instance.findDocumentsById(['doc1', 'doc2', 'doc3'], false);
+
+		expect(result.length).toBe(2);
+		expect(result.map(d => d.id).sort()).toEqual(['doc1', 'doc3']);
+		expect(result.every(d => d._deleted === false)).toBe(true);
+
+		await instance.remove();
+	});
+
+	test('withDeleted=true returns ALL docs (deleted + non-deleted)', async () => {
+		const storage = getRxStorageBunSQLite();
+		const instance = await storage.createStorageInstance({
+			databaseName: 'test-db',
+			collectionName: 'test-collection',
+			schema: testSchema,
+			options: {},
+			multiInstance: false,
+			devMode: false,
+			databaseInstanceToken: 'test-token'
+		});
+
+		const docs: RxDocumentData<TestDoc>[] = [
+			{ id: 'doc1', name: 'Active', age: 25, _deleted: false, _attachments: {}, _rev: '1-a', _meta: { lwt: Date.now() } },
+			{ id: 'doc2', name: 'Deleted', age: 30, _deleted: true, _attachments: {}, _rev: '1-b', _meta: { lwt: Date.now() } },
+			{ id: 'doc3', name: 'Active2', age: 35, _deleted: false, _attachments: {}, _rev: '1-c', _meta: { lwt: Date.now() } }
+		];
+
+		await instance.bulkWrite(docs.map(doc => ({ document: doc })), 'test');
+
+		const result = await instance.findDocumentsById(['doc1', 'doc2', 'doc3'], true);
+
+		expect(result.length).toBe(3);
+		expect(result.map(d => d.id).sort()).toEqual(['doc1', 'doc2', 'doc3']);
+		expect(result.filter(d => d._deleted).length).toBe(1);
+		expect(result.filter(d => !d._deleted).length).toBe(2);
+
+		await instance.remove();
+	});
+
+	test('withDeleted=false with only deleted docs returns empty array', async () => {
+		const storage = getRxStorageBunSQLite();
+		const instance = await storage.createStorageInstance({
+			databaseName: 'test-db',
+			collectionName: 'test-collection',
+			schema: testSchema,
+			options: {},
+			multiInstance: false,
+			devMode: false,
+			databaseInstanceToken: 'test-token'
+		});
+
+		const docs: RxDocumentData<TestDoc>[] = [
+			{ id: 'doc1', name: 'Deleted1', age: 25, _deleted: true, _attachments: {}, _rev: '1-a', _meta: { lwt: Date.now() } },
+			{ id: 'doc2', name: 'Deleted2', age: 30, _deleted: true, _attachments: {}, _rev: '1-b', _meta: { lwt: Date.now() } }
+		];
+
+		await instance.bulkWrite(docs.map(doc => ({ document: doc })), 'test');
+
+		const result = await instance.findDocumentsById(['doc1', 'doc2'], false);
+
+		expect(result.length).toBe(0);
+
+		await instance.remove();
+	});
+});

package/src/index.ts

@@ -0,0 +1,2 @@
+export { getRxStorageBunSQLite } from './storage';
+export type { BunSQLiteStorageSettings } from './types';