@peers-app/peers-sdk 0.14.0 → 0.15.0

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

@@ -1,398 +1,367 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const data_query_mongo_1 = require("./data-query.mongo");
-describe('dataFilterToMongoQuery', () => {
-    describe('Scalar values', () => {
-        it('should handle null values', () => {
+describe("dataFilterToMongoQuery", () => {
+    describe("Scalar values", () => {
+        it("should handle null values", () => {
             expect((0, data_query_mongo_1.dataFilterToMongoQuery)(null)).toBe(null);
         });
-        it('should handle undefined values', () => {
+        it("should handle undefined values", () => {
             expect((0, data_query_mongo_1.dataFilterToMongoQuery)(undefined)).toBe(undefined);
         });
-        it('should handle primitive values', () => {
+        it("should handle primitive values", () => {
             expect((0, data_query_mongo_1.dataFilterToMongoQuery)(42)).toBe(42);
-            expect((0, data_query_mongo_1.dataFilterToMongoQuery)('test')).toBe('test');
+            expect((0, data_query_mongo_1.dataFilterToMongoQuery)("test")).toBe("test");
             expect((0, data_query_mongo_1.dataFilterToMongoQuery)(true)).toBe(true);
         });
-        it('should handle Date objects', () => {
-            const date = new Date('2023-01-01');
+        it("should handle Date objects", () => {
+            const date = new Date("2023-01-01");
             expect((0, data_query_mongo_1.dataFilterToMongoQuery)(date)).toBe(date);
         });
     });
-    describe('Empty filters', () => {
-        it('should handle empty object filters', () => {
+    describe("Empty filters", () => {
+        it("should handle empty object filters", () => {
             expect((0, data_query_mongo_1.dataFilterToMongoQuery)({})).toEqual({});
         });
-        it('should handle empty array filters', () => {
+        it("should handle empty array filters", () => {
             expect((0, data_query_mongo_1.dataFilterToMongoQuery)([])).toEqual({});
         });
     });
-    describe('Simple field conditions', () => {
-        it('should handle basic field equality', () => {
-            const filter = { name: 'John' };
-            expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ name: 'John' });
+    describe("Simple field conditions", () => {
+        it("should handle basic field equality", () => {
+            const filter = { name: "John" };
+            expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ name: "John" });
         });
-        it('should handle multiple fields', () => {
-            const filter = { name: 'John', age: 30 };
-            expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ name: 'John', age: 30 });
+        it("should handle multiple fields", () => {
+            const filter = { name: "John", age: 30 };
+            expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ name: "John", age: 30 });
         });
-        it('should handle null field values', () => {
+        it("should handle null field values", () => {
             const filter = { name: null };
             expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ name: null });
         });
-        it('should handle undefined field values', () => {
+        it("should handle undefined field values", () => {
             const filter = { name: undefined };
             expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ name: null });
         });
-        it('should throw error for direct array usage', () => {
-            const filter = { names: ['John', 'Jane'] };
-            expect(() => (0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toThrow('Invalid filter: Arrays are not allowed as direct field values. Use $in instead');
+        it("should throw error for direct array usage", () => {
+            const filter = { names: ["John", "Jane"] };
+            expect(() => (0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toThrow("Invalid filter: Arrays are not allowed as direct field values. Use $in instead");
         });
     });
-    describe('MongoDB operators (direct mapping)', () => {
-        describe('$eq operator', () => {
-            it('should handle $eq operator', () => {
+    describe("MongoDB operators (direct mapping)", () => {
+        describe("$eq operator", () => {
+            it("should handle $eq operator", () => {
                 const filter = { age: { $eq: 30 } };
                 expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ age: { $eq: 30 } });
             });
         });
-        describe('$ne operator', () => {
-            it('should handle $ne operator', () => {
+        describe("$ne operator", () => {
+            it("should handle $ne operator", () => {
                 const filter = { age: { $ne: 30 } };
                 expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ age: { $ne: 30 } });
             });
         });
-        describe('Comparison operators', () => {
-            it('should handle $gt operator', () => {
+        describe("Comparison operators", () => {
+            it("should handle $gt operator", () => {
                 const filter = { age: { $gt: 18 } };
                 expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ age: { $gt: 18 } });
             });
-            it('should handle $gte operator', () => {
+            it("should handle $gte operator", () => {
                 const filter = { age: { $gte: 18 } };
                 expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ age: { $gte: 18 } });
             });
-            it('should handle $lt operator', () => {
+            it("should handle $lt operator", () => {
                 const filter = { age: { $lt: 65 } };
                 expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ age: { $lt: 65 } });
             });
-            it('should handle $lte operator', () => {
+            it("should handle $lte operator", () => {
                 const filter = { age: { $lte: 65 } };
                 expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ age: { $lte: 65 } });
             });
-            it('should handle multiple comparison operators', () => {
+            it("should handle multiple comparison operators", () => {
                 const filter = { age: { $gte: 18, $lt: 65 } };
                 expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ age: { $gte: 18, $lt: 65 } });
             });
         });
-        describe('$in and $nin operators', () => {
-            it('should handle $in operator', () => {
-                const filter = { status: { $in: ['active', 'pending'] } };
-                expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ status: { $in: ['active', 'pending'] } });
+        describe("$in and $nin operators", () => {
+            it("should handle $in operator", () => {
+                const filter = { status: { $in: ["active", "pending"] } };
+                expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ status: { $in: ["active", "pending"] } });
             });
-            it('should handle $nin operator', () => {
-                const filter = { status: { $nin: ['inactive', 'deleted'] } };
-                expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ status: { $nin: ['inactive', 'deleted'] } });
+            it("should handle $nin operator", () => {
+                const filter = { status: { $nin: ["inactive", "deleted"] } };
+                expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({
+                    status: { $nin: ["inactive", "deleted"] },
+                });
             });
-            it('should handle empty arrays', () => {
+            it("should handle empty arrays", () => {
                 const filter = { status: { $in: [] } };
                 expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ status: { $in: [] } });
             });
         });
-        describe('$exists operator', () => {
-            it('should handle $exists: true', () => {
+        describe("$exists operator", () => {
+            it("should handle $exists: true", () => {
                 const filter = { email: { $exists: true } };
                 expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ email: { $exists: true } });
             });
-            it('should handle $exists: false', () => {
+            it("should handle $exists: false", () => {
                 const filter = { email: { $exists: false } };
                 expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ email: { $exists: false } });
             });
         });
     });
-    describe('Logical operators', () => {
-        describe('$or operator', () => {
-            it('should handle $or with multiple conditions', () => {
-                const filter = { $or: [{ name: 'John' }, { age: 30 }] };
+    describe("Logical operators", () => {
+        describe("$or operator", () => {
+            it("should handle $or with multiple conditions", () => {
+                const filter = { $or: [{ name: "John" }, { age: 30 }] };
                 expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({
-                    $or: [{ name: 'John' }, { age: 30 }]
+                    $or: [{ name: "John" }, { age: 30 }],
                 });
             });
-            it('should handle empty $or array', () => {
+            it("should handle empty $or array", () => {
                 const filter = { $or: [] };
                 expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ $or: [] });
             });
-            it('should handle $or with complex conditions', () => {
+            it("should handle $or with complex conditions", () => {
                 const filter = {
-                    $or: [
-                        { name: 'John', age: { $gte: 18 } },
-                        { status: { $in: ['active', 'pending'] } }
-                    ]
+                    $or: [{ name: "John", age: { $gte: 18 } }, { status: { $in: ["active", "pending"] } }],
                 };
                 expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({
-                    $or: [
-                        { name: 'John', age: { $gte: 18 } },
-                        { status: { $in: ['active', 'pending'] } }
-                    ]
+                    $or: [{ name: "John", age: { $gte: 18 } }, { status: { $in: ["active", "pending"] } }],
                 });
             });
         });
-        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_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({
-                    $and: [{ name: 'John' }, { age: 30 }]
+                    $and: [{ name: "John" }, { age: 30 }],
                 });
             });
-            it('should handle empty $and array', () => {
+            it("should handle empty $and array", () => {
                 const filter = { $and: [] };
                 expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({});
             });
-            it('should handle nested $and and $or', () => {
+            it("should handle nested $and and $or", () => {
                 const filter = {
                     $and: [
-                        { status: 'active' },
+                        { status: "active" },
                         {
-                            $or: [
-                                { age: { $gte: 18 } },
-                                { verified: true }
-                            ]
-                        }
-                    ]
+                            $or: [{ age: { $gte: 18 } }, { verified: true }],
+                        },
+                    ],
                 };
                 expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({
                     $and: [
-                        { status: 'active' },
+                        { status: "active" },
                         {
-                            $or: [
-                                { age: { $gte: 18 } },
-                                { verified: true }
-                            ]
-                        }
-                    ]
+                            $or: [{ age: { $gte: 18 } }, { verified: true }],
+                        },
+                    ],
                 });
             });
         });
-        describe('Array filters (OR logic)', () => {
-            it('should handle single condition arrays', () => {
-                const filter = [{ name: 'John' }];
-                expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ name: 'John' });
+        describe("Array filters (OR logic)", () => {
+            it("should handle single condition arrays", () => {
+                const filter = [{ name: "John" }];
+                expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({ name: "John" });
             });
-            it('should handle multiple condition arrays', () => {
-                const filter = [{ name: 'John' }, { age: 30 }, { city: 'NYC' }];
+            it("should handle multiple condition arrays", () => {
+                const filter = [{ name: "John" }, { age: 30 }, { city: "NYC" }];
                 expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({
-                    $or: [{ name: 'John' }, { age: 30 }, { city: 'NYC' }]
+                    $or: [{ name: "John" }, { age: 30 }, { city: "NYC" }],
                 });
             });
-            it('should handle complex array conditions', () => {
+            it("should handle complex array conditions", () => {
                 const filter = [
-                    { name: 'John', age: { $gte: 18 } },
-                    { status: { $in: ['active', 'pending'] } }
+                    { name: "John", age: { $gte: 18 } },
+                    { status: { $in: ["active", "pending"] } },
                 ];
                 expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({
-                    $or: [
-                        { name: 'John', age: { $gte: 18 } },
-                        { status: { $in: ['active', 'pending'] } }
-                    ]
+                    $or: [{ name: "John", age: { $gte: 18 } }, { status: { $in: ["active", "pending"] } }],
                 });
             });
         });
     });
-    describe('Custom operators', () => {
-        describe('$matchWords operator', () => {
-            it('should throw error for $matchWords (needs field context)', () => {
-                const filter = { $matchWords: 'hello world' };
-                expect(() => (0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toThrow('$matchWords with multiple words requires field context');
+    describe("Custom operators", () => {
+        describe("$matchWords operator", () => {
+            it("should throw error for $matchWords (needs field context)", () => {
+                const filter = { $matchWords: "hello world" };
+                expect(() => (0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toThrow("$matchWords with multiple words requires field context");
             });
-            it('should throw error for non-string values', () => {
+            it("should throw error for non-string values", () => {
                 const filter = { $matchWords: 123 };
-                expect(() => (0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toThrow('$matchWords value must be a string');
+                expect(() => (0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toThrow("$matchWords value must be a string");
             });
         });
-        describe('$substr operator', () => {
-            it('should convert $substr to MongoDB $expr format', () => {
-                const filter = { $substr: ['$fieldName', 1, 3] };
+        describe("$substr operator", () => {
+            it("should convert $substr to MongoDB $expr format", () => {
+                const filter = { $substr: ["$fieldName", 1, 3] };
                 const result = (0, data_query_mongo_1.dataFilterToMongoQuery)(filter);
                 expect(result).toEqual({
                     $expr: {
-                        $substr: ['$fieldName', 1, 3]
-                    }
+                        $substr: ["$fieldName", 1, 3],
+                    },
                 });
             });
-            it('should handle string literals in $substr', () => {
-                const filter = { $substr: ['literal text', 0, 5] };
+            it("should handle string literals in $substr", () => {
+                const filter = { $substr: ["literal text", 0, 5] };
                 const result = (0, data_query_mongo_1.dataFilterToMongoQuery)(filter);
                 expect(result).toEqual({
                     $expr: {
-                        $substr: ['literal text', 0, 5]
-                    }
+                        $substr: ["literal text", 0, 5],
+                    },
                 });
             });
-            it('should throw error for invalid $substr arguments', () => {
-                const filter = { $substr: ['$field'] }; // Missing arguments
-                expect(() => (0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toThrow('$substr requires exactly 3 arguments');
+            it("should throw error for invalid $substr arguments", () => {
+                const filter = { $substr: ["$field"] }; // Missing arguments
+                expect(() => (0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toThrow("$substr requires exactly 3 arguments");
             });
-            it('should throw error for non-array $substr', () => {
-                const filter = { $substr: 'invalid' };
-                expect(() => (0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toThrow('$substr requires exactly 3 arguments');
+            it("should throw error for non-array $substr", () => {
+                const filter = { $substr: "invalid" };
+                expect(() => (0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toThrow("$substr requires exactly 3 arguments");
             });
         });
-        describe('$expr operator', () => {
-            it('should convert simple $expr to MongoDB format', () => {
-                const filter = { $expr: [{ $substr: ['$id', 0, 1] }, { $eq: 'A' }] };
+        describe("$expr operator", () => {
+            it("should convert simple $expr to MongoDB format", () => {
+                const filter = { $expr: [{ $substr: ["$id", 0, 1] }, { $eq: "A" }] };
                 const result = (0, data_query_mongo_1.dataFilterToMongoQuery)(filter);
                 expect(result).toEqual({
                     $expr: {
-                        $eq: [
-                            { $substr: ['$id', 0, 1] },
-                            'A'
-                        ]
-                    }
+                        $eq: [{ $substr: ["$id", 0, 1] }, "A"],
+                    },
                 });
             });
-            it('should handle $expr with different operators', () => {
-                const filter = { $expr: [{ $substr: ['$name', 0, 1] }, { $ne: 'Z' }] };
+            it("should handle $expr with different operators", () => {
+                const filter = { $expr: [{ $substr: ["$name", 0, 1] }, { $ne: "Z" }] };
                 const result = (0, data_query_mongo_1.dataFilterToMongoQuery)(filter);
                 expect(result).toEqual({
                     $expr: {
-                        $ne: [
-                            { $substr: ['$name', 0, 1] },
-                            'Z'
-                        ]
-                    }
+                        $ne: [{ $substr: ["$name", 0, 1] }, "Z"],
+                    },
                 });
             });
-            it('should default to $eq for simple expressions', () => {
-                const filter = { $expr: ['$field1', '$field2'] };
+            it("should default to $eq for simple expressions", () => {
+                const filter = { $expr: ["$field1", "$field2"] };
                 const result = (0, data_query_mongo_1.dataFilterToMongoQuery)(filter);
                 expect(result).toEqual({
                     $expr: {
-                        $eq: ['$field1', '$field2']
-                    }
+                        $eq: ["$field1", "$field2"],
+                    },
                 });
             });
-            it('should throw error for invalid $expr format', () => {
-                const filter = { $expr: ['single_argument'] };
-                expect(() => (0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toThrow('$expr requires exactly 2 arguments');
+            it("should throw error for invalid $expr format", () => {
+                const filter = { $expr: ["single_argument"] };
+                expect(() => (0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toThrow("$expr requires exactly 2 arguments");
             });
         });
     });
-    describe('Error cases', () => {
-        it('should throw error for unknown operators', () => {
-            const filter = { field: { $unknown: 'value' } };
-            expect(() => (0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toThrow('Unknown operator: $unknown');
+    describe("Error cases", () => {
+        it("should throw error for unknown operators", () => {
+            const filter = { field: { $unknown: "value" } };
+            expect(() => (0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toThrow("Unknown operator: $unknown");
         });
-        it('should throw error for operators without $ prefix', () => {
-            const filter = { field: { invalidOp: 'value' } };
-            expect(() => (0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toThrow('Invalid operator: invalidOp. Operators must start with $');
+        it("should throw error for operators without $ prefix", () => {
+            const filter = { field: { invalidOp: "value" } };
+            expect(() => (0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toThrow("Invalid operator: invalidOp. Operators must start with $");
         });
-        it('should throw error for nested $matchWords', () => {
-            const filter = { field: { $matchWords: 'test' } };
-            expect(() => (0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toThrow('$matchWords should be handled at field level');
+        it("should throw error for nested $matchWords", () => {
+            const filter = { field: { $matchWords: "test" } };
+            expect(() => (0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toThrow("$matchWords should be handled at field level");
         });
-        it('should throw error for nested $substr', () => {
-            const filter = { field: { $substr: ['$other', 0, 1] } };
-            expect(() => (0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toThrow('$substr should be handled at field level');
+        it("should throw error for nested $substr", () => {
+            const filter = { field: { $substr: ["$other", 0, 1] } };
+            expect(() => (0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toThrow("$substr should be handled at field level");
         });
-        it('should throw error for nested $expr', () => {
-            const filter = { field: { $expr: ['$a', '$b'] } };
-            expect(() => (0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toThrow('$expr should be handled at field level');
+        it("should throw error for nested $expr", () => {
+            const filter = { field: { $expr: ["$a", "$b"] } };
+            expect(() => (0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toThrow("$expr should be handled at field level");
         });
     });
-    describe('Complex nested scenarios', () => {
-        it('should handle deeply nested conditions', () => {
+    describe("Complex nested scenarios", () => {
+        it("should handle deeply nested conditions", () => {
             const filter = {
                 $and: [
-                    { status: 'active' },
+                    { status: "active" },
                     {
-                        $or: [
-                            { age: { $gte: 18, $lt: 65 } },
-                            { verified: true }
-                        ]
+                        $or: [{ age: { $gte: 18, $lt: 65 } }, { verified: true }],
                     },
-                    { role: { $in: ['user', 'admin'] } }
-                ]
+                    { role: { $in: ["user", "admin"] } },
+                ],
             };
             expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({
                 $and: [
-                    { status: 'active' },
+                    { status: "active" },
                     {
-                        $or: [
-                            { age: { $gte: 18, $lt: 65 } },
-                            { verified: true }
-                        ]
+                        $or: [{ age: { $gte: 18, $lt: 65 } }, { verified: true }],
                     },
-                    { role: { $in: ['user', 'admin'] } }
-                ]
+                    { role: { $in: ["user", "admin"] } },
+                ],
             });
         });
-        it('should handle mixed array and object filters', () => {
+        it("should handle mixed array and object filters", () => {
             const filter = [
-                { name: 'John', age: { $gte: 18 } },
+                { name: "John", age: { $gte: 18 } },
                 {
-                    $and: [
-                        { status: 'active' },
-                        { verified: true }
-                    ]
-                }
+                    $and: [{ status: "active" }, { verified: true }],
+                },
             ];
             expect((0, data_query_mongo_1.dataFilterToMongoQuery)(filter)).toEqual({
                 $or: [
-                    { name: 'John', age: { $gte: 18 } },
+                    { name: "John", age: { $gte: 18 } },
                     {
-                        $and: [
-                            { status: 'active' },
-                            { verified: true }
-                        ]
-                    }
-                ]
+                        $and: [{ status: "active" }, { verified: true }],
+                    },
+                ],
             });
         });
     });
 });
-describe('sortByToMongoSort', () => {
-    it('should handle empty sort', () => {
+describe("sortByToMongoSort", () => {
+    it("should handle empty sort", () => {
         expect((0, data_query_mongo_1.sortByToMongoSort)()).toEqual({});
         expect((0, data_query_mongo_1.sortByToMongoSort)([])).toEqual({});
     });
-    it('should handle ascending sort', () => {
-        expect((0, data_query_mongo_1.sortByToMongoSort)(['name'])).toEqual({ name: 1 });
+    it("should handle ascending sort", () => {
+        expect((0, data_query_mongo_1.sortByToMongoSort)(["name"])).toEqual({ name: 1 });
     });
-    it('should handle descending sort', () => {
-        expect((0, data_query_mongo_1.sortByToMongoSort)(['-name'])).toEqual({ name: -1 });
+    it("should handle descending sort", () => {
+        expect((0, data_query_mongo_1.sortByToMongoSort)(["-name"])).toEqual({ name: -1 });
     });
-    it('should handle multiple sort fields', () => {
-        expect((0, data_query_mongo_1.sortByToMongoSort)(['name', '-age', 'created'])).toEqual({
+    it("should handle multiple sort fields", () => {
+        expect((0, data_query_mongo_1.sortByToMongoSort)(["name", "-age", "created"])).toEqual({
             name: 1,
             age: -1,
-            created: 1
+            created: 1,
         });
     });
-    it('should handle complex field names', () => {
-        expect((0, data_query_mongo_1.sortByToMongoSort)(['-user.name', 'profile.age'])).toEqual({
-            'user.name': -1,
-            'profile.age': 1
+    it("should handle complex field names", () => {
+        expect((0, data_query_mongo_1.sortByToMongoSort)(["-user.name", "profile.age"])).toEqual({
+            "user.name": -1,
+            "profile.age": 1,
         });
     });
 });
-describe('paginationToMongoSkipLimit', () => {
-    it('should handle no pagination', () => {
+describe("paginationToMongoSkipLimit", () => {
+    it("should handle no pagination", () => {
         expect((0, data_query_mongo_1.paginationToMongoSkipLimit)()).toEqual({});
     });
-    it('should handle only pageSize', () => {
+    it("should handle only pageSize", () => {
         expect((0, data_query_mongo_1.paginationToMongoSkipLimit)(undefined, 10)).toEqual({ limit: 10 });
     });
-    it('should handle only page (no effect without pageSize)', () => {
+    it("should handle only page (no effect without pageSize)", () => {
         expect((0, data_query_mongo_1.paginationToMongoSkipLimit)(2)).toEqual({});
     });
-    it('should handle page and pageSize', () => {
+    it("should handle page and pageSize", () => {
         expect((0, data_query_mongo_1.paginationToMongoSkipLimit)(1, 10)).toEqual({ limit: 10 });
         expect((0, data_query_mongo_1.paginationToMongoSkipLimit)(2, 10)).toEqual({ limit: 10, skip: 10 });
         expect((0, data_query_mongo_1.paginationToMongoSkipLimit)(3, 20)).toEqual({ limit: 20, skip: 40 });
     });
-    it('should handle fractional numbers', () => {
+    it("should handle fractional numbers", () => {
         expect((0, data_query_mongo_1.paginationToMongoSkipLimit)(2.7, 10.3)).toEqual({ limit: 10, skip: 21 });
     });
-    it('should handle zero page', () => {
+    it("should handle zero page", () => {
         expect((0, data_query_mongo_1.paginationToMongoSkipLimit)(0, 10)).toEqual({ limit: 10 });
     });
 });

package/dist/data/orm/data-query.sqlite.d.ts

@@ -1,4 +1,4 @@
-import { DataFilter, DataQuery } from './data-query';
+import type { DataFilter, DataQuery } from "./data-query";
 export declare function dataFilterToSqlWhere(filter: DataFilter<any>): string;
 /**
  * Converts a DataQuery to a complete SQLite query string