@peers-app/peers-sdk 0.14.0 → 0.15.0

package/dist/data/orm/data-query.sqlite.test.js

@@ -1,376 +1,364 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const data_query_sqlite_1 = require("./data-query.sqlite");
-describe('dataFilterToSqlWhere - Restructured Version', () => {
-    describe('Main orchestrator function', () => {
-        it('should handle scalar values', () => {
-            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(null)).toBe('NULL');
-            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(undefined)).toBe('NULL');
-            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(true)).toBe('1');
-            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(false)).toBe('0');
-            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(42)).toBe('42');
-            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)('test')).toBe("'test'");
-            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(new Date('2023-01-01T00:00:00.000Z'))).toBe("'2023-01-01T00:00:00.000Z'");
-        });
-        it('should handle empty filter object', () => {
-            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)({})).toBe('(1=1)');
-        });
-        it('should delegate to array handler for arrays', () => {
-            const filter = [{ name: 'John' }, { age: 30 }];
+describe("dataFilterToSqlWhere - Restructured Version", () => {
+    describe("Main orchestrator function", () => {
+        it("should handle scalar values", () => {
+            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(null)).toBe("NULL");
+            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(undefined)).toBe("NULL");
+            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(true)).toBe("1");
+            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(false)).toBe("0");
+            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(42)).toBe("42");
+            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)("test")).toBe("'test'");
+            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(new Date("2023-01-01T00:00:00.000Z"))).toBe("'2023-01-01T00:00:00.000Z'");
+        });
+        it("should handle empty filter object", () => {
+            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)({})).toBe("(1=1)");
+        });
+        it("should delegate to array handler for arrays", () => {
+            const filter = [{ name: "John" }, { age: 30 }];
             expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`(("name" = 'John') OR ("age" = 30))`);
         });
-        it('should delegate to object handler for filter objects', () => {
-            const filter = { name: 'John', age: 30 };
+        it("should delegate to object handler for filter objects", () => {
+            const filter = { name: "John", age: 30 };
             expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("name" = 'John' AND "age" = 30)`);
         });
     });
-    describe('handleOrArray function', () => {
-        it('should handle empty arrays', () => {
-            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)([])).toBe('(1=1)');
+    describe("handleOrArray function", () => {
+        it("should handle empty arrays", () => {
+            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)([])).toBe("(1=1)");
         });
-        it('should handle single condition arrays', () => {
-            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)([{ name: 'John' }])).toBe(`(("name" = 'John'))`);
+        it("should handle single condition arrays", () => {
+            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)([{ name: "John" }])).toBe(`(("name" = 'John'))`);
         });
-        it('should handle multiple conditions with OR', () => {
-            const filter = [{ name: 'John' }, { age: 30 }, { city: 'NYC' }];
+        it("should handle multiple conditions with OR", () => {
+            const filter = [{ name: "John" }, { age: 30 }, { city: "NYC" }];
             expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`(("name" = 'John') OR ("age" = 30) OR ("city" = 'NYC'))`);
         });
-        it('should handle complex nested conditions', () => {
-            const filter = [
-                { name: 'John', age: 30 },
-                { city: { $in: ['NYC', 'LA'] } }
-            ];
+        it("should handle complex nested conditions", () => {
+            const filter = [{ name: "John", age: 30 }, { city: { $in: ["NYC", "LA"] } }];
             expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`(("name" = 'John' AND "age" = 30) OR ("city" IN ('NYC', 'LA')))`);
         });
     });
-    describe('handleFilterObject function', () => {
-        it('should handle multiple field conditions with AND', () => {
-            const filter = { name: 'John', age: 30, active: true };
+    describe("handleFilterObject function", () => {
+        it("should handle multiple field conditions with AND", () => {
+            const filter = { name: "John", age: 30, active: true };
             expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("name" = 'John' AND "age" = 30 AND "active" = 1)`);
         });
-        it('should handle single field condition', () => {
-            const filter = { name: 'John' };
+        it("should handle single field condition", () => {
+            const filter = { name: "John" };
             expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("name" = 'John')`);
         });
     });
-    describe('Special operators', () => {
-        describe('$or operator', () => {
-            it('should handle $or with multiple conditions', () => {
-                const filter = { $or: [{ name: 'John' }, { age: 30 }] };
+    describe("Special operators", () => {
+        describe("$or operator", () => {
+            it("should handle $or with multiple conditions", () => {
+                const filter = { $or: [{ name: "John" }, { age: 30 }] };
                 expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`((("name" = 'John') OR ("age" = 30)))`);
             });
-            it('should handle empty $or array', () => {
+            it("should handle empty $or array", () => {
                 const filter = { $or: [] };
                 expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`((1=1))`);
             });
-            it('should handle $or with empty objects', () => {
+            it("should handle $or with empty objects", () => {
                 const filter = { $or: [{}] };
                 expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`(((1=1)))`);
             });
         });
-        describe('$and operator', () => {
-            it('should handle $and with multiple conditions', () => {
-                const filter = { $and: [{ name: 'John' }, { age: 30 }] };
+        describe("$and operator", () => {
+            it("should handle $and with multiple conditions", () => {
+                const filter = { $and: [{ name: "John" }, { age: 30 }] };
                 expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`((("name" = 'John') AND ("age" = 30)))`);
             });
-            it('should handle empty $and array', () => {
+            it("should handle empty $and array", () => {
                 const filter = { $and: [] };
                 expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`((1=1))`);
             });
-            it('should handle $and with empty objects', () => {
+            it("should handle $and with empty objects", () => {
                 const filter = { $and: [{}] };
                 expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`(((1=1)))`);
             });
         });
-        describe('$expr operator', () => {
-            it('should handle simple expressions', () => {
-                const filter = { $expr: [{ $substr: ['$id', 1, 1] }, { $eq: 'a' }] };
+        describe("$expr operator", () => {
+            it("should handle simple expressions", () => {
+                const filter = { $expr: [{ $substr: ["$id", 1, 1] }, { $eq: "a" }] };
                 expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`((substr("id", 1, 1)) = 'a')`);
             });
-            it('should handle expressions with column references', () => {
-                const filter = { $expr: [{ $substr: ['$col1', 2, 4] }, { $gte: '$col2' }] };
+            it("should handle expressions with column references", () => {
+                const filter = { $expr: [{ $substr: ["$col1", 2, 4] }, { $gte: "$col2" }] };
                 expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`((substr("col1", 2, 4)) >= "col2")`);
             });
         });
-        describe('$substr operator', () => {
-            it('should handle substr with column reference', () => {
-                const filter = { $substr: ['$col1', 2, 4] };
+        describe("$substr operator", () => {
+            it("should handle substr with column reference", () => {
+                const filter = { $substr: ["$col1", 2, 4] };
                 expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`(substr("col1", 2, 4))`);
             });
-            it('should handle substr with string literal', () => {
-                const filter = { $substr: ['test string', 1, 4] };
+            it("should handle substr with string literal", () => {
+                const filter = { $substr: ["test string", 1, 4] };
                 expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`(substr('test string', 1, 4))`);
             });
-            it('should handle substr with escaped quotes', () => {
+            it("should handle substr with escaped quotes", () => {
                 const filter = { $substr: ["test's string", 1, 4] };
                 expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`(substr('test''s string', 1, 4))`);
             });
         });
     });
-    describe('Field operators', () => {
-        describe('$in operator', () => {
-            it('should handle string arrays', () => {
-                const filter = { name: { $in: ['John', 'Jane', 'Bob'] } };
+    describe("Field operators", () => {
+        describe("$in operator", () => {
+            it("should handle string arrays", () => {
+                const filter = { name: { $in: ["John", "Jane", "Bob"] } };
                 expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("name" IN ('John', 'Jane', 'Bob'))`);
             });
-            it('should handle number arrays', () => {
+            it("should handle number arrays", () => {
                 const filter = { age: { $in: [20, 30, 40] } };
                 expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("age" IN (20, 30, 40))`);
             });
-            it('should handle mixed type arrays', () => {
-                const filter = { value: { $in: ['test', 42, null, true] } };
+            it("should handle mixed type arrays", () => {
+                const filter = { value: { $in: ["test", 42, null, true] } };
                 expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("value" IN ('test', 42, NULL, 1))`);
             });
-            it('should handle empty arrays', () => {
+            it("should handle empty arrays", () => {
                 const filter = { name: { $in: [] } };
                 expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("name" IN ())`);
             });
-            it('should throw error for non-array values', () => {
-                const filter = { name: { $in: 'John' } };
-                expect(() => (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toThrow('$in value must be an array');
+            it("should throw error for non-array values", () => {
+                const filter = { name: { $in: "John" } };
+                expect(() => (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toThrow("$in value must be an array");
             });
         });
-        describe('$nin operator', () => {
-            it('should handle string arrays', () => {
-                const filter = { name: { $nin: ['John', 'Jane'] } };
+        describe("$nin operator", () => {
+            it("should handle string arrays", () => {
+                const filter = { name: { $nin: ["John", "Jane"] } };
                 expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("name" NOT IN ('John', 'Jane'))`);
             });
-            it('should handle number arrays', () => {
+            it("should handle number arrays", () => {
                 const filter = { age: { $nin: [20, 30] } };
                 expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("age" NOT IN (20, 30))`);
             });
-            it('should throw error for non-array values', () => {
-                const filter = { name: { $nin: 'John' } };
-                expect(() => (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toThrow('$nin value must be an array');
+            it("should throw error for non-array values", () => {
+                const filter = { name: { $nin: "John" } };
+                expect(() => (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toThrow("$nin value must be an array");
             });
         });
-        describe('$matchWords operator', () => {
-            it('should handle single word', () => {
-                const filter = { description: { $matchWords: 'test' } };
+        describe("$matchWords operator", () => {
+            it("should handle single word", () => {
+                const filter = { description: { $matchWords: "test" } };
                 expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("description" LIKE '%test%')`);
             });
-            it('should handle multiple words', () => {
-                const filter = { description: { $matchWords: 'hello world' } };
+            it("should handle multiple words", () => {
+                const filter = { description: { $matchWords: "hello world" } };
                 expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("description" LIKE '%hello%' AND "description" LIKE '%world%')`);
             });
-            it('should handle words with quotes', () => {
+            it("should handle words with quotes", () => {
                 const filter = { description: { $matchWords: "John's world" } };
                 expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("description" LIKE '%John''s%' AND "description" LIKE '%world%')`);
             });
-            it('should handle multiple quotes', () => {
+            it("should handle multiple quotes", () => {
                 const filter = { description: { $matchWords: "It's John's" } };
                 expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("description" LIKE '%It''s%' AND "description" LIKE '%John''s%')`);
             });
-            it('should throw error for non-string values', () => {
+            it("should throw error for non-string values", () => {
                 const filter = { description: { $matchWords: 123 } };
-                expect(() => (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toThrow('$matchWords value must be a string');
+                expect(() => (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toThrow("$matchWords value must be a string");
             });
         });
-        describe('$exists operator', () => {
-            it('should handle $exists: true', () => {
+        describe("$exists operator", () => {
+            it("should handle $exists: true", () => {
                 const filter = { name: { $exists: true } };
                 expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("name" IS NOT NULL)`);
             });
-            it('should handle $exists: false', () => {
+            it("should handle $exists: false", () => {
                 const filter = { name: { $exists: false } };
                 expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("name" IS NULL)`);
             });
-            it('should handle truthy values', () => {
+            it("should handle truthy values", () => {
                 const filter = { name: { $exists: 1 } };
                 expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("name" IS NOT NULL)`);
             });
-            it('should handle falsy values', () => {
+            it("should handle falsy values", () => {
                 const filter = { name: { $exists: 0 } };
                 expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("name" IS NULL)`);
             });
         });
-        describe('$ne operator', () => {
-            it('should handle string values', () => {
-                const filter = { name: { $ne: 'John' } };
+        describe("$ne operator", () => {
+            it("should handle string values", () => {
+                const filter = { name: { $ne: "John" } };
                 expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`(("name" <> 'John' OR "name" IS NULL))`);
             });
-            it('should handle number values', () => {
+            it("should handle number values", () => {
                 const filter = { age: { $ne: 30 } };
                 expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`(("age" <> 30 OR "age" IS NULL))`);
             });
-            it('should handle null values', () => {
+            it("should handle null values", () => {
                 const filter = { name: { $ne: null } };
                 expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`(("name" <> NULL OR "name" IS NULL))`);
             });
-            it('should escape quotes in strings', () => {
+            it("should escape quotes in strings", () => {
                 const filter = { name: { $ne: "O'Hara" } };
                 expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`(("name" <> 'O''Hara' OR "name" IS NULL))`);
             });
         });
-        describe('Comparison operators', () => {
-            it('should handle $eq operator', () => {
+        describe("Comparison operators", () => {
+            it("should handle $eq operator", () => {
                 const filter = { age: { $eq: 30 } };
                 expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("age" = 30)`);
             });
-            it('should handle $gt operator', () => {
+            it("should handle $gt operator", () => {
                 const filter = { age: { $gt: 30 } };
                 expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("age" > 30)`);
             });
-            it('should handle $gte operator', () => {
+            it("should handle $gte operator", () => {
                 const filter = { age: { $gte: 30 } };
                 expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("age" >= 30)`);
             });
-            it('should handle $lt operator', () => {
+            it("should handle $lt operator", () => {
                 const filter = { age: { $lt: 30 } };
                 expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("age" < 30)`);
             });
-            it('should handle $lte operator', () => {
+            it("should handle $lte operator", () => {
                 const filter = { age: { $lte: 30 } };
                 expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("age" <= 30)`);
             });
-            it('should handle string values with comparison operators', () => {
-                const filter = { name: { $gt: 'John' } };
+            it("should handle string values with comparison operators", () => {
+                const filter = { name: { $gt: "John" } };
                 expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("name" > 'John')`);
             });
-            it('should handle date values', () => {
-                const date = new Date('2023-01-01T00:00:00.000Z');
+            it("should handle date values", () => {
+                const date = new Date("2023-01-01T00:00:00.000Z");
                 const filter = { created: { $gte: date } };
                 expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("created" >= '2023-01-01T00:00:00.000Z')`);
             });
         });
     });
-    describe('Field conditions', () => {
-        it('should handle null field values', () => {
+    describe("Field conditions", () => {
+        it("should handle null field values", () => {
             const filter = { name: null };
             expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("name" IS NULL)`);
         });
-        it('should handle undefined field values', () => {
+        it("should handle undefined field values", () => {
             const filter = { name: undefined };
             expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("name" IS NULL)`);
         });
-        it('should handle simple field values', () => {
-            const filter = { name: 'John', age: 30, active: true };
+        it("should handle simple field values", () => {
+            const filter = { name: "John", age: 30, active: true };
             expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("name" = 'John' AND "age" = 30 AND "active" = 1)`);
         });
-        it('should throw error for direct array usage', () => {
-            const filter = { names: ['John', 'Jane'] };
+        it("should throw error for direct array usage", () => {
+            const filter = { names: ["John", "Jane"] };
             expect(() => (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toThrow(`Invalid filter: Arrays are not allowed as direct field values. Use $in instead: { names: { $in: ['John', 'Jane'] } }`);
         });
-        it('should throw error for direct array usage with more items', () => {
-            const filter = { names: ['John', 'Jane', 'Bob', 'Alice'] };
+        it("should throw error for direct array usage with more items", () => {
+            const filter = { names: ["John", "Jane", "Bob", "Alice"] };
             expect(() => (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toThrow(`Invalid filter: Arrays are not allowed as direct field values. Use $in instead: { names: { $in: ['John', 'Jane', ...] } }`);
         });
     });
-    describe('Field name escaping', () => {
-        it('should escape field names with double quotes', () => {
-            const filter = { 'field"name': 'test' };
+    describe("Field name escaping", () => {
+        it("should escape field names with double quotes", () => {
+            const filter = { 'field"name': "test" };
             expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("field""name" = 'test')`);
         });
-        it('should escape field names with multiple double quotes', () => {
-            const filter = { 'field"with"quotes': 'test' };
+        it("should escape field names with multiple double quotes", () => {
+            const filter = { 'field"with"quotes': "test" };
             expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("field""with""quotes" = 'test')`);
         });
-        it('should handle normal field names', () => {
-            const filter = { fieldName: 'test' };
+        it("should handle normal field names", () => {
+            const filter = { fieldName: "test" };
             expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("fieldName" = 'test')`);
         });
     });
-    describe('String value handling', () => {
-        it('should escape single quotes in string values', () => {
+    describe("String value handling", () => {
+        it("should escape single quotes in string values", () => {
             const filter = { name: "John's" };
             expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("name" = 'John''s')`);
         });
-        it('should escape multiple single quotes', () => {
+        it("should escape multiple single quotes", () => {
             const filter = { name: "It's John's" };
             expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("name" = 'It''s John''s')`);
         });
-        it('should handle column references with $ prefix', () => {
-            const filter = { name: '$other_column' };
+        it("should handle column references with $ prefix", () => {
+            const filter = { name: "$other_column" };
             expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("name" = "other_column")`);
         });
-        it('should handle escaped $ prefix', () => {
-            const filter = { name: '\\$literal' };
+        it("should handle escaped $ prefix", () => {
+            const filter = { name: "\\$literal" };
             expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("name" = '$literal')`);
         });
-        it('should handle backslash not followed by $', () => {
-            const filter = { name: '\\literal' };
+        it("should handle backslash not followed by $", () => {
+            const filter = { name: "\\literal" };
             expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("name" = '\\literal')`);
         });
-        it('should escape double quotes in column references', () => {
+        it("should escape double quotes in column references", () => {
             const filter = { name: '$col"with"quotes' };
             expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("name" = "col""with""quotes")`);
         });
     });
-    describe('Error cases', () => {
-        it('should throw error for unknown operators', () => {
-            const filter = { name: { $unknown: 'test' } };
-            expect(() => (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toThrow('Unknown operator: $unknown');
+    describe("Error cases", () => {
+        it("should throw error for unknown operators", () => {
+            const filter = { name: { $unknown: "test" } };
+            expect(() => (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toThrow("Unknown operator: $unknown");
         });
-        it('should throw error for invalid object values', () => {
-            const filter = { name: { invalidKey: 'test' } };
-            expect(() => (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toThrow('Invalid object value for field name');
+        it("should throw error for invalid object values", () => {
+            const filter = { name: { invalidKey: "test" } };
+            expect(() => (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toThrow("Invalid object value for field name");
         });
-        it('should throw error for multiple operators in object', () => {
-            const filter = { name: { $eq: 'test', $ne: 'other' } };
-            expect(() => (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toThrow('Invalid object value for field name');
+        it("should throw error for multiple operators in object", () => {
+            const filter = { name: { $eq: "test", $ne: "other" } };
+            expect(() => (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toThrow("Invalid object value for field name");
         });
-        it('should throw error for unknown scalar types', () => {
-            const filter = { name: Symbol('test') };
-            expect(() => (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toThrow('Cannot convert a Symbol value to a string');
+        it("should throw error for unknown scalar types", () => {
+            const filter = { name: Symbol("test") };
+            expect(() => (0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toThrow("Cannot convert a Symbol value to a string");
         });
     });
-    describe('Complex nested scenarios', () => {
-        it('should handle deeply nested conditions', () => {
+    describe("Complex nested scenarios", () => {
+        it("should handle deeply nested conditions", () => {
             const filter = {
                 $and: [
-                    { name: 'John' },
+                    { name: "John" },
                     {
-                        $or: [
-                            { age: { $gte: 30 } },
-                            { city: { $in: ['NYC', 'LA'] } }
-                        ]
-                    }
-                ]
+                        $or: [{ age: { $gte: 30 } }, { city: { $in: ["NYC", "LA"] } }],
+                    },
+                ],
             };
-            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`((("name" = 'John') AND (((\"age\" >= 30) OR (\"city\" IN ('NYC', 'LA'))))))`);
+            expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`((("name" = 'John') AND ((("age" >= 30) OR ("city" IN ('NYC', 'LA'))))))`);
         });
-        it('should handle mixed operators and conditions', () => {
+        it("should handle mixed operators and conditions", () => {
             const filter = {
-                name: { $ne: 'John' },
-                $and: [
-                    { age: { $gte: 25 } },
-                    { age: { $lte: 65 } }
-                ],
-                $or: [
-                    { city: 'NYC' },
-                    { state: 'CA' }
-                ]
+                name: { $ne: "John" },
+                $and: [{ age: { $gte: 25 } }, { age: { $lte: 65 } }],
+                $or: [{ city: "NYC" }, { state: "CA" }],
             };
             expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`(("name" <> 'John' OR "name" IS NULL) AND (("age" >= 25) AND ("age" <= 65)) AND (("city" = 'NYC') OR ("state" = 'CA')))`);
         });
-        it('should handle arrays with complex conditions', () => {
+        it("should handle arrays with complex conditions", () => {
             const filter = [
-                { name: 'John', age: { $gte: 30 } },
-                { city: { $in: ['NYC', 'LA'] }, active: true }
+                { name: "John", age: { $gte: 30 } },
+                { city: { $in: ["NYC", "LA"] }, active: true },
             ];
             expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`(("name" = 'John' AND "age" >= 30) OR ("city" IN ('NYC', 'LA') AND "active" = 1))`);
         });
     });
-    describe('Edge cases', () => {
-        it('should handle empty strings', () => {
-            const filter = { name: '' };
+    describe("Edge cases", () => {
+        it("should handle empty strings", () => {
+            const filter = { name: "" };
             expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("name" = '')`);
         });
-        it('should handle zero values', () => {
+        it("should handle zero values", () => {
             const filter = { count: 0 };
             expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("count" = 0)`);
         });
-        it('should handle boolean false', () => {
+        it("should handle boolean false", () => {
             const filter = { active: false };
             expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("active" = 0)`);
         });
-        it('should handle very long strings', () => {
-            const longString = 'a'.repeat(1000);
+        it("should handle very long strings", () => {
+            const longString = "a".repeat(1000);
             const filter = { description: longString };
             expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("description" = '${longString}')`);
         });
-        it('should handle special characters in field names', () => {
-            const filter = { 'field-with-dashes': 'test', 'field_with_underscores': 'test2' };
+        it("should handle special characters in field names", () => {
+            const filter = { "field-with-dashes": "test", field_with_underscores: "test2" };
             expect((0, data_query_sqlite_1.dataFilterToSqlWhere)(filter)).toBe(`("field-with-dashes" = 'test' AND "field_with_underscores" = 'test2')`);
         });
     });