bun-sqlite-for-rxdb 1.0.1

package/src/query/operators.ts

@@ -0,0 +1,185 @@
+export interface SqlFragment {
+	sql: string;
+	args: (string | number | boolean | null)[];
+}
+
+import { smartRegexToLike } from './smart-regex';
+
+export function translateEq(field: string, value: unknown): SqlFragment {
+	if (value === null) {
+		return { sql: `${field} IS NULL`, args: [] };
+	}
+	return { sql: `${field} = ?`, args: [value as string | number | boolean] };
+}
+
+export function translateNe(field: string, value: unknown): SqlFragment {
+	if (value === null) {
+		return { sql: `${field} IS NOT NULL`, args: [] };
+	}
+	return { sql: `${field} <> ?`, args: [value as string | number | boolean] };
+}
+
+export function translateGt(field: string, value: unknown): SqlFragment {
+	return { sql: `${field} > ?`, args: [value as string | number] };
+}
+
+export function translateGte(field: string, value: unknown): SqlFragment {
+	return { sql: `${field} >= ?`, args: [value as string | number] };
+}
+
+export function translateLt(field: string, value: unknown): SqlFragment {
+	return { sql: `${field} < ?`, args: [value as string | number] };
+}
+
+export function translateLte(field: string, value: unknown): SqlFragment {
+	return { sql: `${field} <= ?`, args: [value as string | number] };
+}
+
+export function translateIn(field: string, values: unknown[]): SqlFragment {
+	if (!Array.isArray(values) || values.length === 0) {
+		return { sql: '1=0', args: [] };
+	}
+
+	const hasNull = values.includes(null);
+	const nonNullValues = values.filter(v => v !== null) as (string | number | boolean)[];
+
+	if (nonNullValues.length === 0) {
+		return { sql: `${field} IS NULL`, args: [] };
+	}
+
+	const placeholders = nonNullValues.map(() => '?').join(', ');
+	const inClause = `${field} IN (${placeholders})`;
+
+	if (hasNull) {
+		return { 
+			sql: `(${inClause} OR ${field} IS NULL)`, 
+			args: nonNullValues 
+		};
+	}
+
+	return { sql: inClause, args: nonNullValues };
+}
+
+export function translateNin(field: string, values: unknown[]): SqlFragment {
+	if (!Array.isArray(values) || values.length === 0) {
+		return { sql: '1=1', args: [] };
+	}
+
+	const hasNull = values.includes(null);
+	const nonNullValues = values.filter(v => v !== null) as (string | number | boolean)[];
+
+	if (nonNullValues.length === 0) {
+		return { sql: `${field} IS NOT NULL`, args: [] };
+	}
+
+	const placeholders = nonNullValues.map(() => '?').join(', ');
+	const ninClause = `${field} NOT IN (${placeholders})`;
+
+	if (hasNull) {
+		return { 
+			sql: `(${ninClause} AND ${field} IS NOT NULL)`, 
+			args: nonNullValues 
+		};
+	}
+
+	return { sql: ninClause, args: nonNullValues };
+}
+
+export function translateExists(field: string, exists: boolean): SqlFragment {
+	return {
+		sql: exists ? `${field} IS NOT NULL` : `${field} IS NULL`,
+		args: []
+	};
+}
+
+export function translateRegex(field: string, pattern: string, options?: string): SqlFragment | null {
+	const smartResult = smartRegexToLike(field, pattern, options);
+	if (smartResult) return smartResult;
+	
+	return null;
+}
+
+export function translateElemMatch(field: string, criteria: any): SqlFragment | null {
+	return null;
+}
+
+export function translateNot(field: string, criteria: any): SqlFragment {
+	const inner = processOperatorValue(field, criteria);
+	return {
+		sql: `NOT(${inner.sql})`,
+		args: inner.args
+	};
+}
+
+export function translateNor(conditions: any[]): SqlFragment {
+	if (conditions.length === 0) {
+		return { sql: '1=1', args: [] };
+	}
+	
+	const fragments = conditions.map(condition => {
+		const [[field, value]] = Object.entries(condition);
+		return processOperatorValue(field, value);
+	});
+	
+	const sql = fragments.map(f => `(${f.sql})`).join(' OR ');
+	const args = fragments.flatMap(f => f.args);
+	
+	return {
+		sql: `NOT(${sql})`,
+		args
+	};
+}
+
+function processOperatorValue(field: string, value: any): SqlFragment {
+	if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+		const [[op, opValue]] = Object.entries(value);
+		
+		switch (op) {
+			case '$eq': return translateEq(field, opValue);
+			case '$ne': return translateNe(field, opValue);
+			case '$gt': return translateGt(field, opValue);
+			case '$gte': return translateGte(field, opValue);
+			case '$lt': return translateLt(field, opValue);
+			case '$lte': return translateLte(field, opValue);
+			case '$in': return translateIn(field, opValue as unknown[]);
+			case '$nin': return translateNin(field, opValue as unknown[]);
+			default: return translateEq(field, opValue);
+		}
+	}
+	
+	return translateEq(field, value);
+}
+
+export function translateType(field: string, type: string): SqlFragment | null {
+	switch (type) {
+		case 'number':
+			return { 
+				sql: `(typeof(${field}) = 'integer' OR typeof(${field}) = 'real')`, 
+				args: [] 
+			};
+		case 'string':
+			return { sql: `typeof(${field}) = 'text'`, args: [] };
+		case 'null':
+			return { sql: `typeof(${field}) = 'null'`, args: [] };
+		case 'boolean':
+		case 'array':
+		case 'object':
+		case 'date':
+		default:
+			return null;
+	}
+}
+
+export function translateSize(field: string, size: number): SqlFragment {
+	return {
+		sql: `json_array_length(${field}) = ?`,
+		args: [size]
+	};
+}
+
+export function translateMod(field: string, [divisor, remainder]: [number, number]): SqlFragment {
+	return {
+		sql: `${field} % ? = ?`,
+		args: [divisor, remainder]
+	};
+}

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

@@ -0,0 +1,68 @@
+import { describe, it, expect } from 'bun:test';
+import { buildWhereClause } from './builder';
+import type { RxJsonSchema } from 'rxdb';
+
+const testSchema: RxJsonSchema<any> = {
+	version: 0,
+	primaryKey: 'id',
+	type: 'object',
+	properties: {
+		id: { type: 'string' },
+		age: { type: 'number' },
+		status: { type: 'string' },
+		deleted: { type: 'boolean' }
+	}
+};
+
+describe('$or operator', () => {
+	it('generates simple OR clause', () => {
+		const result = buildWhereClause({
+			$or: [
+				{ age: 25 },
+				{ age: 30 }
+			]
+		}, testSchema);
+		
+		expect(result.sql).toBe('json_extract(data, \'$.age\') = ? OR json_extract(data, \'$.age\') = ?');
+		expect(result.args).toEqual([25, 30]);
+	});
+
+	it('handles OR with nested AND', () => {
+		const result = buildWhereClause({
+			$or: [
+				{ age: { $gt: 50 } },
+				{ $and: [{ age: { $eq: 50 } }, { status: 'active' }] }
+			]
+		}, testSchema);
+		
+		expect(result.sql).toContain('json_extract(data, \'$.age\') > ?');
+		expect(result.sql).toContain('OR');
+		expect(result.sql).toContain('(json_extract(data, \'$.age\') = ? AND json_extract(data, \'$.status\') = ?)');
+		expect(result.args).toEqual([50, 50, 'active']);
+	});
+
+	it('handles complex nested OR with parentheses', () => {
+		const result = buildWhereClause({
+			$or: [
+				{ age: { $gt: 50 } },
+				{ $and: [{ age: { $eq: 50 } }, { status: 'active' }] },
+				{
+					$and: [
+						{ deleted: false },
+						{
+							$or: [
+								{ age: { $lte: 30 } },
+								{ age: 30 },
+								{ age: 35 }
+							]
+						}
+					]
+				}
+			]
+		}, testSchema);
+		
+		expect(result.sql).toContain('OR');
+		expect(result.sql).toContain('(');
+		expect(result.sql).toContain(')');
+	});
+});

package/src/query/regex-escaping-regression.test.ts

@@ -0,0 +1,43 @@
+import { describe, test, expect } from "bun:test";
+import { Database } from "bun:sqlite";
+import { translateRegex } from "./operators";
+
+describe("Regex operator - % and _ escaping regression test", () => {
+	test("case-insensitive exact match with % character should escape properly", () => {
+		const db = new Database(":memory:");
+		db.run(`CREATE TABLE test (id TEXT PRIMARY KEY, data TEXT)`);
+		
+		db.run(`INSERT INTO test (id, data) VALUES ('1', '{"name": "100%"}')`);
+		db.run(`INSERT INTO test (id, data) VALUES ('2', '{"name": "100x"}')`);
+		db.run(`INSERT INTO test (id, data) VALUES ('3', '{"name": "50%"}')`);
+		
+		const result = translateRegex("json_extract(data, '$.name')", '^100%$', 'i');
+		
+		expect(result).not.toBeNull();
+		const rows = db.query(`SELECT * FROM test WHERE ${result!.sql}`).all(...result!.args);
+		
+		expect(rows.length).toBe(1);
+		expect(JSON.parse((rows[0] as any).data).name).toBe("100%");
+		
+		db.close();
+	});
+	
+	test("case-insensitive exact match with _ character should escape properly", () => {
+		const db = new Database(":memory:");
+		db.run(`CREATE TABLE test (id TEXT PRIMARY KEY, data TEXT)`);
+		
+		db.run(`INSERT INTO test (id, data) VALUES ('1', '{"name": "test_name"}')`);
+		db.run(`INSERT INTO test (id, data) VALUES ('2', '{"name": "testxname"}')`);
+		db.run(`INSERT INTO test (id, data) VALUES ('3', '{"name": "test-name"}')`);
+		
+		const result = translateRegex("json_extract(data, '$.name')", '^test_name$', 'i');
+		
+		expect(result).not.toBeNull();
+		const rows = db.query(`SELECT * FROM test WHERE ${result!.sql}`).all(...result!.args);
+		
+		expect(rows.length).toBe(1);
+		expect(JSON.parse((rows[0] as any).data).name).toBe("test_name");
+		
+		db.close();
+	});
+});

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

@@ -0,0 +1,44 @@
+import { describe, it, expect } from 'bun:test';
+import { translateRegex } from './operators';
+
+describe('$regex Operator', () => {
+	it('translates simple pattern to LIKE', () => {
+		const result = translateRegex('name', '^John');
+		expect(result?.sql).toBe("name LIKE ? ESCAPE '\\'");
+		expect(result?.args).toEqual(['John%']);
+	});
+
+	it('translates end anchor to LIKE', () => {
+		const result = translateRegex('email', '@gmail\\.com$');
+		expect(result?.sql).toBe("email LIKE ? ESCAPE '\\'");
+		expect(result?.args).toEqual(['%@gmail.com']);
+	});
+
+	it('translates contains pattern to LIKE', () => {
+		const result = translateRegex('description', 'urgent');
+		expect(result?.sql).toBe("description LIKE ? ESCAPE '\\'");
+		expect(result?.args).toEqual(['%urgent%']);
+	});
+
+	it('escapes LIKE special chars', () => {
+		const result = translateRegex('username', 'user_name');
+		expect(result?.sql).toBe("username LIKE ? ESCAPE '\\'");
+		expect(result?.args).toEqual(['%user\\_name%']);
+	});
+
+	it('handles case-insensitive with COLLATE NOCASE', () => {
+		const result = translateRegex('name', 'john', 'i');
+		expect(result?.sql).toBe("name LIKE ? COLLATE NOCASE ESCAPE '\\'");
+		expect(result?.args).toEqual(['%john%']);
+	});
+
+	it('returns null for complex regex patterns', () => {
+		const result = translateRegex('phone', '\\d{3}-\\d{4}');
+		expect(result).toBeNull();
+	});
+
+	it('returns null for character classes', () => {
+		const result = translateRegex('code', '[A-Z]{3}');
+		expect(result).toBeNull();
+	});
+});

package/src/query/schema-mapper.ts

@@ -0,0 +1,27 @@
+import type { RxJsonSchema, RxDocumentData } from 'rxdb';
+
+export interface ColumnInfo {
+	column?: string;
+	jsonPath?: string;
+	type: 'string' | 'number' | 'boolean' | 'unknown';
+}
+
+export function getColumnInfo<RxDocType>(path: string, schema: RxJsonSchema<RxDocumentData<RxDocType>>): ColumnInfo {
+	if (path === '_deleted') {
+		return { column: 'deleted', type: 'boolean' };
+	}
+	
+	if (path === '_meta.lwt') {
+		return { column: 'mtime_ms', type: 'number' };
+	}
+	
+	if (path === '_rev') {
+		return { column: 'rev', type: 'string' };
+	}
+	
+	if (path === schema.primaryKey) {
+		return { column: 'id', type: 'string' };
+	}
+	
+	return { jsonPath: `$.${path}`, type: 'unknown' };
+}

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

@@ -0,0 +1,22 @@
+import { describe, it, expect } from 'bun:test';
+import { translateSize } from './operators';
+
+describe('$size Operator', () => {
+	it('translates array size check to json_array_length', () => {
+		const result = translateSize('tags', 3);
+		expect(result?.sql).toBe('json_array_length(tags) = ?');
+		expect(result?.args).toEqual([3]);
+	});
+
+	it('handles size 0', () => {
+		const result = translateSize('items', 0);
+		expect(result?.sql).toBe('json_array_length(items) = ?');
+		expect(result?.args).toEqual([0]);
+	});
+
+	it('handles large array sizes', () => {
+		const result = translateSize('data', 100);
+		expect(result?.sql).toBe('json_array_length(data) = ?');
+		expect(result?.args).toEqual([100]);
+	});
+});

package/src/query/smart-regex.ts

@@ -0,0 +1,52 @@
+export interface SqlFragment {
+	sql: string;
+	args: (string | number | boolean)[];
+}
+
+export function smartRegexToLike(field: string, pattern: string, options?: string): SqlFragment | null {
+	const caseInsensitive = options?.includes('i');
+	
+	const startsWithAnchor = pattern.startsWith('^');
+	const endsWithAnchor = pattern.endsWith('$');
+	
+	let cleanPattern = pattern.replace(/^\^/, '').replace(/\$$/, '');
+	
+	if (startsWithAnchor && endsWithAnchor && !/[*+?()[\]{}|]/.test(cleanPattern)) {
+		const exact = cleanPattern.replace(/\\\./g, '.');
+		if (caseInsensitive) {
+			const escaped = exact.replace(/%/g, '\\%').replace(/_/g, '\\_');
+			return { sql: `${field} LIKE ? COLLATE NOCASE ESCAPE '\\'`, args: [escaped] };
+		}
+		return { sql: `${field} = ?`, args: [exact] };
+	}
+	
+	if (startsWithAnchor) {
+		const prefix = cleanPattern.replace(/\\\./g, '.');
+		if (!/[*+?()[\]{}|]/.test(prefix)) {
+			const escaped = prefix.replace(/%/g, '\\%').replace(/_/g, '\\_');
+			return caseInsensitive
+				? { sql: `${field} LIKE ? COLLATE NOCASE ESCAPE '\\'`, args: [escaped + '%'] }
+				: { sql: `${field} LIKE ? ESCAPE '\\'`, args: [escaped + '%'] };
+		}
+	}
+	
+	if (endsWithAnchor) {
+		const suffix = cleanPattern.replace(/\\\./g, '.');
+		if (!/[*+?()[\]{}|]/.test(suffix)) {
+			const escaped = suffix.replace(/%/g, '\\%').replace(/_/g, '\\_');
+			return caseInsensitive
+				? { sql: `${field} LIKE ? COLLATE NOCASE ESCAPE '\\'`, args: ['%' + escaped] }
+				: { sql: `${field} LIKE ? ESCAPE '\\'`, args: ['%' + escaped] };
+		}
+	}
+	
+	cleanPattern = cleanPattern.replace(/\\\./g, '.');
+	if (!/[*+?()[\]{}|^$]/.test(cleanPattern)) {
+		const escaped = cleanPattern.replace(/%/g, '\\%').replace(/_/g, '\\_');
+		return caseInsensitive
+			? { sql: `${field} LIKE ? COLLATE NOCASE ESCAPE '\\'`, args: ['%' + escaped + '%'] }
+			: { sql: `${field} LIKE ? ESCAPE '\\'`, args: ['%' + escaped + '%'] };
+	}
+	
+	return null;
+}

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

@@ -0,0 +1,37 @@
+import { describe, it, expect } from 'bun:test';
+import { translateType } from './operators';
+
+describe('$type Operator', () => {
+	it('translates number type to typeof check', () => {
+		const result = translateType('age', 'number');
+		expect(result?.sql).toBe("(typeof(age) = 'integer' OR typeof(age) = 'real')");
+		expect(result?.args).toEqual([]);
+	});
+
+	it('translates string type to typeof check', () => {
+		const result = translateType('name', 'string');
+		expect(result?.sql).toBe("typeof(name) = 'text'");
+		expect(result?.args).toEqual([]);
+	});
+
+	it('translates null type to typeof check', () => {
+		const result = translateType('deleted', 'null');
+		expect(result?.sql).toBe("typeof(deleted) = 'null'");
+		expect(result?.args).toEqual([]);
+	});
+
+	it('returns null for boolean type (Mingo fallback)', () => {
+		const result = translateType('active', 'boolean');
+		expect(result).toBeNull();
+	});
+
+	it('returns null for array type (Mingo fallback)', () => {
+		const result = translateType('tags', 'array');
+		expect(result).toBeNull();
+	});
+
+	it('returns null for object type (Mingo fallback)', () => {
+		const result = translateType('metadata', 'object');
+		expect(result).toBeNull();
+	});
+});