bun-sqlite-for-rxdb 1.0.1

package/src/query/builder.test.ts

@@ -0,0 +1,96 @@
+import { describe, it, expect } from 'bun:test';
+import { buildWhereClause } from './builder';
+import type { RxJsonSchema, RxDocumentData } from 'rxdb';
+
+interface TestDocType {
+	id: string;
+	name: string;
+	age: number;
+	status: string;
+}
+
+const mockSchema: RxJsonSchema<RxDocumentData<TestDocType>> = {
+	version: 0,
+	primaryKey: 'id',
+	type: 'object',
+	properties: {
+		id: { type: 'string' },
+		name: { type: 'string' },
+		age: { type: 'number' },
+		status: { type: 'string' },
+		_deleted: { type: 'boolean' },
+		_attachments: { type: 'object' },
+		_rev: { type: 'string' },
+		_meta: { 
+			type: 'object',
+			properties: {
+				lwt: { type: 'number' }
+			}
+		}
+	},
+	required: ['id', '_deleted', '_attachments', '_rev', '_meta']
+};
+
+describe('Query Builder', () => {
+	describe('buildWhereClause', () => {
+		it('builds simple equality', () => {
+			const result = buildWhereClause({ age: 18 }, mockSchema);
+			expect(result.sql).toContain('=');
+			expect(result.args).toEqual([18]);
+		});
+
+		it('builds $gt operator', () => {
+			const result = buildWhereClause({ age: { $gt: 18 } }, mockSchema);
+			expect(result.sql).toContain('>');
+			expect(result.args).toEqual([18]);
+		});
+
+		it('builds $gte operator', () => {
+			const result = buildWhereClause({ age: { $gte: 18 } }, mockSchema);
+			expect(result.sql).toContain('>=');
+			expect(result.args).toEqual([18]);
+		});
+
+		it('builds $lt operator', () => {
+			const result = buildWhereClause({ age: { $lt: 18 } }, mockSchema);
+			expect(result.sql).toContain('<');
+			expect(result.args).toEqual([18]);
+		});
+
+		it('builds $lte operator', () => {
+			const result = buildWhereClause({ age: { $lte: 18 } }, mockSchema);
+			expect(result.sql).toContain('<=');
+			expect(result.args).toEqual([18]);
+		});
+
+		it('builds multiple conditions with AND', () => {
+			const result = buildWhereClause({ age: 18, status: 'active' }, mockSchema);
+			expect(result.sql).toContain('AND');
+			expect(result.args).toEqual([18, 'active']);
+		});
+
+		it('handles null values', () => {
+			const result = buildWhereClause({ status: { $eq: null } }, mockSchema);
+			expect(result.sql).toContain('IS NULL');
+			expect(result.args).toEqual([]);
+		});
+
+		it('handles empty selector', () => {
+			const result = buildWhereClause({}, mockSchema);
+			expect(result.sql).toBe('1=1');
+			expect(result.args).toEqual([]);
+		});
+
+		it('uses column for _deleted', () => {
+			const result = buildWhereClause({ _deleted: false }, mockSchema);
+			expect(result.sql).toContain('deleted');
+			expect(result.args).toEqual([false]);
+		});
+
+		it('uses column for primary key', () => {
+			const result = buildWhereClause({ id: 'user1' }, mockSchema);
+			expect(result.sql).toContain('id');
+			expect(result.args).toEqual(['user1']);
+		});
+	});
+});

package/src/query/builder.ts

@@ -0,0 +1,154 @@
+import type { RxJsonSchema, MangoQuerySelector, RxDocumentData } from 'rxdb';
+import { getColumnInfo } from './schema-mapper';
+import { translateEq, translateNe, translateGt, translateGte, translateLt, translateLte, translateIn, translateNin, translateExists, translateRegex, translateElemMatch, translateNot, translateNor, translateType, translateSize, translateMod } from './operators';
+import type { SqlFragment } from './operators';
+import stringify from 'fast-stable-stringify';
+
+const QUERY_CACHE = new Map<string, SqlFragment>();
+const MAX_CACHE_SIZE = 500;
+
+export function getCacheSize(): number {
+	return QUERY_CACHE.size;
+}
+
+export function clearCache(): void {
+	QUERY_CACHE.clear();
+}
+
+export function buildWhereClause<RxDocType>(
+	selector: MangoQuerySelector<RxDocumentData<RxDocType>>,
+	schema: RxJsonSchema<RxDocumentData<RxDocType>>
+): SqlFragment {
+	const cacheKey = `v${schema.version}_${stringify(selector)}`;
+	
+	const cached = QUERY_CACHE.get(cacheKey);
+	if (cached) {
+		QUERY_CACHE.delete(cacheKey);
+		QUERY_CACHE.set(cacheKey, cached);
+		return cached;
+	}
+	
+	const result = processSelector(selector, schema, 0);
+	
+	if (QUERY_CACHE.size >= MAX_CACHE_SIZE) {
+		const firstKey = QUERY_CACHE.keys().next().value;
+		if (firstKey) QUERY_CACHE.delete(firstKey);
+	}
+	
+	QUERY_CACHE.set(cacheKey, result);
+	return result;
+}
+
+function processSelector<RxDocType>(
+	selector: MangoQuerySelector<RxDocumentData<RxDocType>>,
+	schema: RxJsonSchema<RxDocumentData<RxDocType>>,
+	logicalDepth: number
+): SqlFragment {
+	const conditions: string[] = [];
+	const args: (string | number | boolean | null)[] = [];
+	
+	for (const [field, value] of Object.entries(selector)) {
+		if (field === '$and' && Array.isArray(value)) {
+			const andFragments = value.map(subSelector => processSelector(subSelector, schema, logicalDepth));
+			const andConditions = andFragments.map(f => f.sql);
+			const needsParens = logicalDepth > 0 && andConditions.length > 1;
+			const joined = andConditions.join(' AND ');
+			conditions.push(needsParens ? `(${joined})` : joined);
+			andFragments.forEach(f => args.push(...f.args));
+			continue;
+		}
+
+		if (field === '$or' && Array.isArray(value)) {
+			const orFragments = value.map(subSelector => processSelector(subSelector, schema, logicalDepth + 1));
+			const orConditions = orFragments.map(f => f.sql);
+			const needsParens = logicalDepth > 0 && orConditions.length > 1;
+			const joined = orConditions.join(' OR ');
+			conditions.push(needsParens ? `(${joined})` : joined);
+			orFragments.forEach(f => args.push(...f.args));
+			continue;
+		}
+
+		if (field === '$nor' && Array.isArray(value)) {
+			const norFragment = translateNor(value);
+			conditions.push(norFragment.sql);
+			args.push(...norFragment.args);
+			continue;
+		}
+
+		const columnInfo = getColumnInfo(field, schema);
+		const fieldName = columnInfo.column || `json_extract(data, '${columnInfo.jsonPath}')`;
+		
+		if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+			for (const [op, opValue] of Object.entries(value)) {
+				let fragment: SqlFragment;
+				
+				switch (op) {
+					case '$eq':
+						fragment = translateEq(fieldName, opValue);
+						break;
+					case '$ne':
+						fragment = translateNe(fieldName, opValue);
+						break;
+					case '$gt':
+						fragment = translateGt(fieldName, opValue);
+						break;
+					case '$gte':
+						fragment = translateGte(fieldName, opValue);
+						break;
+					case '$lt':
+						fragment = translateLt(fieldName, opValue);
+						break;
+					case '$lte':
+						fragment = translateLte(fieldName, opValue);
+						break;
+					case '$in':
+						fragment = translateIn(fieldName, opValue as unknown[]);
+						break;
+					case '$nin':
+						fragment = translateNin(fieldName, opValue as unknown[]);
+						break;
+					case '$exists':
+						fragment = translateExists(fieldName, opValue as boolean);
+						break;
+					case '$regex':
+						const options = (value as Record<string, unknown>).$options as string | undefined;
+						const regexFragment = translateRegex(fieldName, opValue as string, options);
+						if (!regexFragment) continue;
+						fragment = regexFragment;
+						break;
+					case '$elemMatch':
+						const elemMatchFragment = translateElemMatch(fieldName, opValue);
+						if (!elemMatchFragment) continue;
+						fragment = elemMatchFragment;
+						break;
+					case '$not':
+						fragment = translateNot(fieldName, opValue);
+						break;
+					case '$type':
+						const typeFragment = translateType(fieldName, opValue as string);
+						if (!typeFragment) continue;
+						fragment = typeFragment;
+						break;
+					case '$size':
+						fragment = translateSize(fieldName, opValue as number);
+						break;
+					case '$mod':
+						fragment = translateMod(fieldName, opValue as [number, number]);
+						break;
+					default:
+						continue;
+				}
+				
+				conditions.push(fragment.sql);
+				args.push(...fragment.args);
+			}
+		} else {
+			const fragment = translateEq(fieldName, value);
+			conditions.push(fragment.sql);
+			args.push(...fragment.args);
+		}
+	}
+	
+	const where = conditions.length > 0 ? conditions.join(' AND ') : '1=1';
+	return { sql: where, args };
+}

package/src/query/elemMatch-operator.test.ts

@@ -0,0 +1,24 @@
+import { describe, it, expect } from 'bun:test';
+import { translateElemMatch } from './operators';
+
+describe('$elemMatch Operator', () => {
+	it('returns null for simple equality match', () => {
+		const result = translateElemMatch('tags', { $eq: 'urgent' });
+		expect(result).toBeNull();
+	});
+
+	it('returns null for object with multiple conditions', () => {
+		const result = translateElemMatch('items', { price: { $gt: 100 }, qty: { $gte: 5 } });
+		expect(result).toBeNull();
+	});
+
+	it('returns null for nested conditions', () => {
+		const result = translateElemMatch('awards', { award: 'Turing Award', year: { $gt: 1980 } });
+		expect(result).toBeNull();
+	});
+
+	it('returns null for complex nested operators', () => {
+		const result = translateElemMatch('data', { $and: [{ status: 'active' }, { count: { $gte: 10 } }] });
+		expect(result).toBeNull();
+	});
+});

package/src/query/exists-operator.test.ts

@@ -0,0 +1,28 @@
+import { describe, it, expect } from 'bun:test';
+import { translateExists } from './operators';
+
+describe('$exists Operator', () => {
+	it('translates $exists: true to IS NOT NULL', () => {
+		const result = translateExists('age', true);
+		expect(result.sql).toBe('age IS NOT NULL');
+		expect(result.args).toEqual([]);
+	});
+
+	it('translates $exists: false to IS NULL', () => {
+		const result = translateExists('age', false);
+		expect(result.sql).toBe('age IS NULL');
+		expect(result.args).toEqual([]);
+	});
+
+	it('works with nested fields using json_extract', () => {
+		const result = translateExists("json_extract(data, '$.address.city')", true);
+		expect(result.sql).toBe("json_extract(data, '$.address.city') IS NOT NULL");
+		expect(result.args).toEqual([]);
+	});
+
+	it('handles boolean false correctly', () => {
+		const result = translateExists('status', false);
+		expect(result.sql).toBe('status IS NULL');
+		expect(result.args).toEqual([]);
+	});
+});

package/src/query/in-operators.test.ts

@@ -0,0 +1,54 @@
+import { describe, it, expect } from 'bun:test';
+import { translateIn, translateNin } from './operators';
+
+describe('$in operator', () => {
+	it('generates IN clause for array of values', () => {
+		const result = translateIn('age', [25, 30, 35]);
+		expect(result.sql).toBe('age IN (?, ?, ?)');
+		expect(result.args).toEqual([25, 30, 35]);
+	});
+
+	it('handles NULL in array with OR IS NULL', () => {
+		const result = translateIn('status', ['active', null, 'pending']);
+		expect(result.sql).toBe('(status IN (?, ?) OR status IS NULL)');
+		expect(result.args).toEqual(['active', 'pending']);
+	});
+
+	it('handles array with only NULL', () => {
+		const result = translateIn('field', [null]);
+		expect(result.sql).toBe('field IS NULL');
+		expect(result.args).toEqual([]);
+	});
+
+	it('handles empty array as always false', () => {
+		const result = translateIn('field', []);
+		expect(result.sql).toBe('1=0');
+		expect(result.args).toEqual([]);
+	});
+});
+
+describe('$nin operator', () => {
+	it('generates NOT IN clause for array of values', () => {
+		const result = translateNin('age', [25, 30, 35]);
+		expect(result.sql).toBe('age NOT IN (?, ?, ?)');
+		expect(result.args).toEqual([25, 30, 35]);
+	});
+
+	it('handles NULL in array with AND IS NOT NULL', () => {
+		const result = translateNin('status', ['archived', null, 'deleted']);
+		expect(result.sql).toBe('(status NOT IN (?, ?) AND status IS NOT NULL)');
+		expect(result.args).toEqual(['archived', 'deleted']);
+	});
+
+	it('handles array with only NULL', () => {
+		const result = translateNin('field', [null]);
+		expect(result.sql).toBe('field IS NOT NULL');
+		expect(result.args).toEqual([]);
+	});
+
+	it('handles empty array as always true', () => {
+		const result = translateNin('field', []);
+		expect(result.sql).toBe('1=1');
+		expect(result.args).toEqual([]);
+	});
+});

package/src/query/mod-operator.test.ts

@@ -0,0 +1,22 @@
+import { describe, it, expect } from 'bun:test';
+import { translateMod } from './operators';
+
+describe('$mod Operator', () => {
+	it('translates modulo check to % operator', () => {
+		const result = translateMod('count', [5, 0]);
+		expect(result?.sql).toBe('count % ? = ?');
+		expect(result?.args).toEqual([5, 0]);
+	});
+
+	it('handles non-zero remainder', () => {
+		const result = translateMod('age', [10, 3]);
+		expect(result?.sql).toBe('age % ? = ?');
+		expect(result?.args).toEqual([10, 3]);
+	});
+
+	it('handles divisor of 1', () => {
+		const result = translateMod('value', [1, 0]);
+		expect(result?.sql).toBe('value % ? = ?');
+		expect(result?.args).toEqual([1, 0]);
+	});
+});

package/src/query/nested-query.test.ts

@@ -0,0 +1,198 @@
+import { describe, expect, test } from 'bun:test';
+import { buildWhereClause } from './builder';
+import type { MangoQuerySelector, RxJsonSchema, RxDocumentData } from 'rxdb';
+
+interface TestDocType {
+	id: string;
+	name: string;
+	age: number;
+	status: string;
+	verified: boolean;
+	country: string;
+	role: string;
+}
+
+const mockSchema: RxJsonSchema<RxDocumentData<TestDocType>> = {
+	version: 0,
+	primaryKey: 'id',
+	type: 'object',
+	properties: {
+		id: { type: 'string' },
+		name: { type: 'string' },
+		age: { type: 'number' },
+		status: { type: 'string' },
+		verified: { type: 'boolean' },
+		country: { type: 'string' },
+		role: { type: 'string' },
+		_deleted: { type: 'boolean' },
+		_attachments: { type: 'object' },
+		_rev: { type: 'string' },
+		_meta: { 
+			type: 'object',
+			properties: {
+				lwt: { type: 'number' }
+			}
+		}
+	},
+	required: ['id']
+};
+
+describe('Nested Query Builder - Depth Tracking', () => {
+	test('deeply nested $or inside $and inside $or', () => {
+		const selector: MangoQuerySelector<any> = {
+			$or: [
+				{
+					$and: [
+						{ age: { $gte: 30 } },
+						{
+							$or: [
+								{ status: 'active' },
+								{ status: 'premium' }
+							]
+						}
+					]
+				},
+				{ age: { $lt: 18 } }
+			]
+		};
+
+		const result = buildWhereClause(selector, mockSchema);
+
+		expect(result.sql).toBe(
+			"(json_extract(data, '$.age') >= ? AND (json_extract(data, '$.status') = ? OR json_extract(data, '$.status') = ?)) OR json_extract(data, '$.age') < ?"
+		);
+		expect(result.args).toEqual([30, 'active', 'premium', 18]);
+	});
+
+	test('triple nested $and inside $or inside $and', () => {
+		const selector: MangoQuerySelector<any> = {
+			$and: [
+				{ name: { $ne: null } },
+				{
+					$or: [
+						{
+							$and: [
+								{ age: { $gte: 21 } },
+								{ status: 'verified' }
+							]
+						},
+						{ role: 'admin' }
+					]
+				}
+			]
+		};
+
+		const result = buildWhereClause(selector, mockSchema);
+
+		expect(result.sql).toBe(
+			"json_extract(data, '$.name') IS NOT NULL AND (json_extract(data, '$.age') >= ? AND json_extract(data, '$.status') = ?) OR json_extract(data, '$.role') = ?"
+		);
+		expect(result.args).toEqual([21, 'verified', 'admin']);
+	});
+
+	test('complex nested with $in inside $or inside $and', () => {
+		const selector: MangoQuerySelector<any> = {
+			$and: [
+				{
+					$or: [
+						{ age: { $in: [18, 19, 20] } },
+						{ status: 'student' }
+					]
+				},
+				{ verified: true }
+			]
+		};
+
+		const result = buildWhereClause(selector, mockSchema);
+
+		expect(result.sql).toBe(
+			"json_extract(data, '$.age') IN (?, ?, ?) OR json_extract(data, '$.status') = ? AND json_extract(data, '$.verified') = ?"
+		);
+		expect(result.args).toEqual([18, 19, 20, 'student', true]);
+	});
+
+	test('four-level nesting with mixed operators', () => {
+		const selector: MangoQuerySelector<any> = {
+			$or: [
+				{
+					$and: [
+						{ country: 'US' },
+						{
+							$or: [
+								{
+									$and: [
+										{ age: { $gte: 18 } },
+										{ age: { $lte: 65 } }
+									]
+								},
+								{ status: 'exempt' }
+							]
+						}
+					]
+				},
+				{ role: 'admin' }
+			]
+		};
+
+		const result = buildWhereClause(selector, mockSchema);
+
+		expect(result.sql).toBe(
+			"(json_extract(data, '$.country') = ? AND ((json_extract(data, '$.age') >= ? AND json_extract(data, '$.age') <= ?) OR json_extract(data, '$.status') = ?)) OR json_extract(data, '$.role') = ?"
+		);
+		expect(result.args).toEqual(['US', 18, 65, 'exempt', 'admin']);
+	});
+
+	test('nested $or with $nin and $gt', () => {
+		const selector: MangoQuerySelector<any> = {
+			$or: [
+				{
+					$and: [
+						{ status: { $nin: ['banned', 'suspended'] } },
+						{ age: { $gt: 21 } }
+					]
+				},
+				{ role: { $in: ['admin', 'moderator'] } }
+			]
+		};
+
+		const result = buildWhereClause(selector, mockSchema);
+
+		expect(result.sql).toBe(
+			"(json_extract(data, '$.status') NOT IN (?, ?) AND json_extract(data, '$.age') > ?) OR json_extract(data, '$.role') IN (?, ?)"
+		);
+		expect(result.args).toEqual(['banned', 'suspended', 21, 'admin', 'moderator']);
+	});
+
+	test('parentheses placement with single $or at root', () => {
+		const selector: MangoQuerySelector<any> = {
+			$or: [
+				{ age: { $lt: 18 } },
+				{ age: { $gt: 65 } }
+			]
+		};
+
+		const result = buildWhereClause(selector, mockSchema);
+
+		expect(result.sql).toBe("json_extract(data, '$.age') < ? OR json_extract(data, '$.age') > ?");
+		expect(result.args).toEqual([18, 65]);
+	});
+
+	test('parentheses placement with nested $or at depth 1', () => {
+		const selector: MangoQuerySelector<any> = {
+			$and: [
+				{ verified: true },
+				{
+					$or: [
+						{ status: 'active' },
+						{ status: 'trial' }
+					]
+				}
+			]
+		};
+
+		const result = buildWhereClause(selector, mockSchema);
+
+		expect(result.sql).toBe("json_extract(data, '$.verified') = ? AND json_extract(data, '$.status') = ? OR json_extract(data, '$.status') = ?");
+		expect(result.args).toEqual([true, 'active', 'trial']);
+	});
+});

package/src/query/not-operators.test.ts

@@ -0,0 +1,49 @@
+import { describe, it, expect } from 'bun:test';
+import { translateNot, translateNor } from './operators';
+
+describe('$not Operator', () => {
+	it('negates simple equality', () => {
+		const result = translateNot('age', { $eq: 25 });
+		expect(result.sql).toBe('NOT(age = ?)');
+		expect(result.args).toEqual([25]);
+	});
+
+	it('negates greater than', () => {
+		const result = translateNot('age', { $gt: 50 });
+		expect(result.sql).toBe('NOT(age > ?)');
+		expect(result.args).toEqual([50]);
+	});
+
+	it('negates IN operator', () => {
+		const result = translateNot('status', { $in: ['active', 'pending'] });
+		expect(result.sql).toBe('NOT(status IN (?, ?))');
+		expect(result.args).toEqual(['active', 'pending']);
+	});
+});
+
+describe('$nor Operator', () => {
+	it('negates OR of two conditions', () => {
+		const result = translateNor([
+			{ age: { $lt: 18 } },
+			{ age: { $gt: 65 } }
+		]);
+		expect(result.sql).toBe('NOT((age < ?) OR (age > ?))');
+		expect(result.args).toEqual([18, 65]);
+	});
+
+	it('negates OR of multiple conditions', () => {
+		const result = translateNor([
+			{ status: { $eq: 'inactive' } },
+			{ status: { $eq: 'deleted' } },
+			{ status: { $eq: 'banned' } }
+		]);
+		expect(result.sql).toBe('NOT((status = ?) OR (status = ?) OR (status = ?))');
+		expect(result.args).toEqual(['inactive', 'deleted', 'banned']);
+	});
+
+	it('handles empty array', () => {
+		const result = translateNor([]);
+		expect(result.sql).toBe('1=1');
+		expect(result.args).toEqual([]);
+	});
+});

package/src/query/operators.test.ts

@@ -0,0 +1,70 @@
+import { describe, it, expect } from 'bun:test';
+import { translateEq, translateNe, translateGt, translateGte, translateLt, translateLte } from './operators';
+
+describe('Query Operators', () => {
+	describe('translateEq', () => {
+		it('translates equality with value', () => {
+			const result = translateEq('age', 18);
+			expect(result.sql).toBe('age = ?');
+			expect(result.args).toEqual([18]);
+		});
+
+		it('translates equality with null', () => {
+			const result = translateEq('status', null);
+			expect(result.sql).toBe('status IS NULL');
+			expect(result.args).toEqual([]);
+		});
+
+		it('translates equality with string', () => {
+			const result = translateEq('name', 'Alice');
+			expect(result.sql).toBe('name = ?');
+			expect(result.args).toEqual(['Alice']);
+		});
+	});
+
+	describe('translateNe', () => {
+		it('translates not equal with value', () => {
+			const result = translateNe('age', 18);
+			expect(result.sql).toBe('age <> ?');
+			expect(result.args).toEqual([18]);
+		});
+
+		it('translates not equal with null', () => {
+			const result = translateNe('status', null);
+			expect(result.sql).toBe('status IS NOT NULL');
+			expect(result.args).toEqual([]);
+		});
+	});
+
+	describe('translateGt', () => {
+		it('translates greater than', () => {
+			const result = translateGt('age', 18);
+			expect(result.sql).toBe('age > ?');
+			expect(result.args).toEqual([18]);
+		});
+	});
+
+	describe('translateGte', () => {
+		it('translates greater than or equal', () => {
+			const result = translateGte('age', 18);
+			expect(result.sql).toBe('age >= ?');
+			expect(result.args).toEqual([18]);
+		});
+	});
+
+	describe('translateLt', () => {
+		it('translates less than', () => {
+			const result = translateLt('age', 18);
+			expect(result.sql).toBe('age < ?');
+			expect(result.args).toEqual([18]);
+		});
+	});
+
+	describe('translateLte', () => {
+		it('translates less than or equal', () => {
+			const result = translateLte('age', 18);
+			expect(result.sql).toBe('age <= ?');
+			expect(result.args).toEqual([18]);
+		});
+	});
+});