bun-sqlite-for-rxdb 1.0.1 → 1.1.3

package/src/collection-isolation.test.ts

@@ -1,74 +0,0 @@
-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

@@ -1,102 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,122 +0,0 @@
-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();
-	});
-});