@peers-app/peers-sdk 0.14.0 → 0.15.0

package/dist/data/orm/multi-cursors.test.js

@@ -1,14 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const multi_cursors_1 = require("./multi-cursors");
+const field_type_1 = require("../../types/field-type");
 const data_query_1 = require("./data-query");
 const factory_1 = require("./factory");
-const field_type_1 = require("../../types/field-type");
+const multi_cursors_1 = require("./multi-cursors");
 function createMockCursor(items) {
     let index = 0;
     const cursor = {
         value: null,
-        next: async (skipPast) => {
+        next: async (_skipPast) => {
             if (index >= items.length) {
                 cursor.value = null;
                 return null;
@@ -20,8 +20,8 @@ function createMockCursor(items) {
     };
     return (0, data_query_1.iterableCursor)(cursor);
 }
-describe('cursorUnion', () => {
-    it('should return items from first cursor, then second cursor in order', async () => {
+describe("cursorUnion", () => {
+    it("should return items from first cursor, then second cursor in order", async () => {
         const cursor1 = createMockCursor([1, 2, 3]);
         const cursor2 = createMockCursor([4, 5, 6]);
         const unionCursor = (0, multi_cursors_1.cursorUnion)([cursor1, cursor2]);
@@ -31,7 +31,7 @@ describe('cursorUnion', () => {
         }
         expect(results).toEqual([1, 2, 3, 4, 5, 6]);
     });
-    it('should handle empty cursors gracefully', async () => {
+    it("should handle empty cursors gracefully", async () => {
         const cursor1 = createMockCursor([1, 2]);
         const cursor2 = createMockCursor([]);
         const cursor3 = createMockCursor([3, 4]);
@@ -42,7 +42,7 @@ describe('cursorUnion', () => {
         }
         expect(results).toEqual([1, 2, 3, 4]);
     });
-    it('should return empty result when all cursors are empty', async () => {
+    it("should return empty result when all cursors are empty", async () => {
         const cursor1 = createMockCursor([]);
         const cursor2 = createMockCursor([]);
         const unionCursor = (0, multi_cursors_1.cursorUnion)([cursor1, cursor2]);
@@ -52,16 +52,16 @@ describe('cursorUnion', () => {
         }
         expect(results).toEqual([]);
     });
-    it('should work with single cursor', async () => {
-        const cursor1 = createMockCursor(['a', 'b', 'c']);
+    it("should work with single cursor", async () => {
+        const cursor1 = createMockCursor(["a", "b", "c"]);
         const unionCursor = (0, multi_cursors_1.cursorUnion)([cursor1]);
         const results = [];
         for await (const item of unionCursor) {
             results.push(item);
         }
-        expect(results).toEqual(['a', 'b', 'c']);
+        expect(results).toEqual(["a", "b", "c"]);
     });
-    it('should work with no cursors', async () => {
+    it("should work with no cursors", async () => {
         const unionCursor = (0, multi_cursors_1.cursorUnion)([]);
         const results = [];
         for await (const item of unionCursor) {
@@ -69,7 +69,7 @@ describe('cursorUnion', () => {
         }
         expect(results).toEqual([]);
     });
-    it('should work with manual next() calls', async () => {
+    it("should work with manual next() calls", async () => {
         const cursor1 = createMockCursor([10, 20]);
         const cursor2 = createMockCursor([30, 40]);
         const unionCursor = (0, multi_cursors_1.cursorUnion)([cursor1, cursor2]);
@@ -79,118 +79,126 @@ describe('cursorUnion', () => {
         }
         expect(results).toEqual([10, 20, 30, 40]);
     });
-    it('should handle different data types', async () => {
-        const cursor1 = createMockCursor([{ id: 1, name: 'John' }, { id: 2, name: 'Jane' }]);
-        const cursor2 = createMockCursor([{ id: 3, name: 'Bob' }]);
+    it("should handle different data types", async () => {
+        const cursor1 = createMockCursor([
+            { id: 1, name: "John" },
+            { id: 2, name: "Jane" },
+        ]);
+        const cursor2 = createMockCursor([{ id: 3, name: "Bob" }]);
         const unionCursor = (0, multi_cursors_1.cursorUnion)([cursor1, cursor2]);
         const results = [];
         for await (const item of unionCursor) {
             results.push(item);
         }
         expect(results).toEqual([
-            { id: 1, name: 'John' },
-            { id: 2, name: 'Jane' },
-            { id: 3, name: 'Bob' }
+            { id: 1, name: "John" },
+            { id: 2, name: "Jane" },
+            { id: 3, name: "Bob" },
         ]);
     });
-    it('should maintain cursor.value correctly', async () => {
-        const cursor1 = createMockCursor(['first', 'second']);
-        const cursor2 = createMockCursor(['third']);
+    it("should maintain cursor.value correctly", async () => {
+        const cursor1 = createMockCursor(["first", "second"]);
+        const cursor2 = createMockCursor(["third"]);
         const unionCursor = (0, multi_cursors_1.cursorUnion)([cursor1, cursor2]);
         // First item
         await unionCursor.next();
-        expect(unionCursor.value).toBe('first');
+        expect(unionCursor.value).toBe("first");
         // Second item
         await unionCursor.next();
-        expect(unionCursor.value).toBe('second');
+        expect(unionCursor.value).toBe("second");
         // Third item (from second cursor)
         await unionCursor.next();
-        expect(unionCursor.value).toBe('third');
+        expect(unionCursor.value).toBe("third");
         // End of data
         const result = await unionCursor.next();
         expect(result).toBeNull();
         expect(unionCursor.value).toBeNull();
     });
 });
-function createMockDataSource(items, tableName, primaryKeyName = 'id') {
+function createMockDataSource(items, tableName, primaryKeyName = "id") {
     return (0, factory_1.arrayAsTable)(items, {
         name: tableName,
-        primaryKeyName
+        primaryKeyName,
     });
 }
-describe('sortLikeSQL', () => {
-    it('should sort by ascending field correctly', () => {
-        const a = { id: 1, name: 'Alice' };
-        const b = { id: 2, name: 'Bob' };
-        expect((0, multi_cursors_1.sortLikeSQL)(['id'], a, b)).toBe(-1); // a < b
-        expect((0, multi_cursors_1.sortLikeSQL)(['id'], b, a)).toBe(1); // b > a
-        expect((0, multi_cursors_1.sortLikeSQL)(['id'], a, a)).toBe(0); // a === a
-    });
-    it('should sort by descending field correctly', () => {
-        const a = { id: 1, name: 'Alice' };
-        const b = { id: 2, name: 'Bob' };
-        expect((0, multi_cursors_1.sortLikeSQL)(['-id'], a, b)).toBe(1); // a > b (desc)
-        expect((0, multi_cursors_1.sortLikeSQL)(['-id'], b, a)).toBe(-1); // b < a (desc)
-        expect((0, multi_cursors_1.sortLikeSQL)(['-id'], a, a)).toBe(0); // a === a
-    });
-    it('should handle multiple sort fields', () => {
-        const a = { name: 'Alice', age: 25 };
-        const b = { name: 'Alice', age: 30 };
-        const c = { name: 'Bob', age: 25 };
+describe("sortLikeSQL", () => {
+    it("should sort by ascending field correctly", () => {
+        const a = { id: 1, name: "Alice" };
+        const b = { id: 2, name: "Bob" };
+        expect((0, multi_cursors_1.sortLikeSQL)(["id"], a, b)).toBe(-1); // a < b
+        expect((0, multi_cursors_1.sortLikeSQL)(["id"], b, a)).toBe(1); // b > a
+        expect((0, multi_cursors_1.sortLikeSQL)(["id"], a, a)).toBe(0); // a === a
+    });
+    it("should sort by descending field correctly", () => {
+        const a = { id: 1, name: "Alice" };
+        const b = { id: 2, name: "Bob" };
+        expect((0, multi_cursors_1.sortLikeSQL)(["-id"], a, b)).toBe(1); // a > b (desc)
+        expect((0, multi_cursors_1.sortLikeSQL)(["-id"], b, a)).toBe(-1); // b < a (desc)
+        expect((0, multi_cursors_1.sortLikeSQL)(["-id"], a, a)).toBe(0); // a === a
+    });
+    it("should handle multiple sort fields", () => {
+        const a = { name: "Alice", age: 25 };
+        const b = { name: "Alice", age: 30 };
+        const c = { name: "Bob", age: 25 };
         // First by name, then by age
-        expect((0, multi_cursors_1.sortLikeSQL)(['name', 'age'], a, b)).toBe(-1); // same name, a.age < b.age
-        expect((0, multi_cursors_1.sortLikeSQL)(['name', 'age'], a, c)).toBe(-1); // a.name < c.name
-        expect((0, multi_cursors_1.sortLikeSQL)(['name', 'age'], c, a)).toBe(1); // c.name > a.name
+        expect((0, multi_cursors_1.sortLikeSQL)(["name", "age"], a, b)).toBe(-1); // same name, a.age < b.age
+        expect((0, multi_cursors_1.sortLikeSQL)(["name", "age"], a, c)).toBe(-1); // a.name < c.name
+        expect((0, multi_cursors_1.sortLikeSQL)(["name", "age"], c, a)).toBe(1); // c.name > a.name
     });
-    it('should handle null/undefined values like SQL', () => {
+    it("should handle null/undefined values like SQL", () => {
         const a = { id: 1, name: null };
-        const b = { id: 2, name: 'Bob' };
+        const b = { id: 2, name: "Bob" };
         const c = { id: 3 }; // name is undefined
-        expect((0, multi_cursors_1.sortLikeSQL)(['name'], a, b)).toBe(-1); // null < string (treated as -Infinity)
-        expect((0, multi_cursors_1.sortLikeSQL)(['name'], c, b)).toBe(-1); // undefined < string (treated as -Infinity)
-        expect((0, multi_cursors_1.sortLikeSQL)(['name'], a, c)).toBe(0); // null === undefined (both -Infinity)
+        expect((0, multi_cursors_1.sortLikeSQL)(["name"], a, b)).toBe(-1); // null < string (treated as -Infinity)
+        expect((0, multi_cursors_1.sortLikeSQL)(["name"], c, b)).toBe(-1); // undefined < string (treated as -Infinity)
+        expect((0, multi_cursors_1.sortLikeSQL)(["name"], a, c)).toBe(0); // null === undefined (both -Infinity)
     });
 });
-describe('queryMerge', () => {
-    it('should merge data from multiple sources in sorted order', async () => {
+describe("queryMerge", () => {
+    it("should merge data from multiple sources in sorted order", async () => {
         const dataSource1 = createMockDataSource([
-            { id: 1, name: 'Alice' },
-            { id: 3, name: 'Charlie' },
-            { id: 5, name: 'Eve' },
-        ], 'table1');
+            { id: 1, name: "Alice" },
+            { id: 3, name: "Charlie" },
+            { id: 5, name: "Eve" },
+        ], "table1");
         const dataSource2 = createMockDataSource([
-            { id: 2, name: 'Bob' },
-            { id: 4, name: 'David' },
-            { id: 6, name: 'Frank' },
-        ], 'table2');
+            { id: 2, name: "Bob" },
+            { id: 4, name: "David" },
+            { id: 6, name: "Frank" },
+        ], "table2");
         const cursor = (0, multi_cursors_1.queryMerge)([dataSource1, dataSource2]);
         const results = [];
         for await (const item of cursor) {
             results.push(item);
         }
-        expect(results.map(r => r.id)).toEqual([1, 2, 3, 4, 5, 6]);
-        expect(results.map(r => r.name)).toEqual(['Alice', 'Bob', 'Charlie', 'David', 'Eve', 'Frank']);
+        expect(results.map((r) => r.id)).toEqual([1, 2, 3, 4, 5, 6]);
+        expect(results.map((r) => r.name)).toEqual([
+            "Alice",
+            "Bob",
+            "Charlie",
+            "David",
+            "Eve",
+            "Frank",
+        ]);
     });
-    it('should handle empty data sources', async () => {
+    it("should handle empty data sources", async () => {
         const dataSource1 = (0, factory_1.arrayAsTable)([], {
-            name: 'table1',
-            primaryKeyName: 'id',
+            name: "table1",
+            primaryKeyName: "id",
             fields: [
-                { name: 'id', type: field_type_1.FieldType.number },
-                { name: 'name', type: field_type_1.FieldType.string }
-            ]
+                { name: "id", type: field_type_1.FieldType.number },
+                { name: "name", type: field_type_1.FieldType.string },
+            ],
         });
-        const dataSource2 = createMockDataSource([
-            { id: 1, name: 'Alice' },
-        ], 'table2');
+        const dataSource2 = createMockDataSource([{ id: 1, name: "Alice" }], "table2");
         const cursor = (0, multi_cursors_1.queryMerge)([dataSource1, dataSource2]);
         const results = [];
         for await (const item of cursor) {
             results.push(item);
         }
-        expect(results).toEqual([{ id: 1, name: 'Alice' }]);
+        expect(results).toEqual([{ id: 1, name: "Alice" }]);
     });
-    it('should handle no data sources', async () => {
+    it("should handle no data sources", async () => {
         const cursor = (0, multi_cursors_1.queryMerge)([]);
         const results = [];
         for await (const item of cursor) {
@@ -198,51 +206,51 @@ describe('queryMerge', () => {
         }
         expect(results).toEqual([]);
     });
-    it('should respect custom sort order', async () => {
+    it("should respect custom sort order", async () => {
         // Use pre-sorted data to avoid arrayAsTable sorting issues
         const dataSource1 = createMockDataSource([
-            { id: 1, name: 'Alice', age: 30 },
-            { id: 3, name: 'Charlie', age: 25 },
-        ], 'table1');
+            { id: 1, name: "Alice", age: 30 },
+            { id: 3, name: "Charlie", age: 25 },
+        ], "table1");
         const dataSource2 = createMockDataSource([
-            { id: 2, name: 'Bob', age: 28 },
-            { id: 4, name: 'David', age: 22 },
-        ], 'table2');
+            { id: 2, name: "Bob", age: 28 },
+            { id: 4, name: "David", age: 22 },
+        ], "table2");
         // Sort by name ascending - data sources already have data in correct order
-        const cursor = (0, multi_cursors_1.queryMerge)([dataSource1, dataSource2], {}, { sortBy: ['name'] });
+        const cursor = (0, multi_cursors_1.queryMerge)([dataSource1, dataSource2], {}, { sortBy: ["name"] });
         const results = [];
         for await (const item of cursor) {
             results.push(item);
         }
-        expect(results.map(r => r.name)).toEqual(['Alice', 'Bob', 'Charlie', 'David']);
+        expect(results.map((r) => r.name)).toEqual(["Alice", "Bob", "Charlie", "David"]);
     });
-    it('should work with single data source', async () => {
+    it("should work with single data source", async () => {
         const dataSource = createMockDataSource([
-            { id: 1, name: 'Alice' },
-            { id: 2, name: 'Bob' },
-            { id: 3, name: 'Charlie' },
-        ], 'table1');
+            { id: 1, name: "Alice" },
+            { id: 2, name: "Bob" },
+            { id: 3, name: "Charlie" },
+        ], "table1");
         const cursor = (0, multi_cursors_1.queryMerge)([dataSource]);
         const results = [];
         for await (const item of cursor) {
             results.push(item);
         }
         // Should be sorted by id (default primary key sort)
-        expect(results.map(r => r.id)).toEqual([1, 2, 3]);
+        expect(results.map((r) => r.id)).toEqual([1, 2, 3]);
     });
-    it('should work with manual next() calls', async () => {
-        const dataSource1 = createMockDataSource([{ id: 1, name: 'Alice' }], 'table1');
-        const dataSource2 = createMockDataSource([{ id: 2, name: 'Bob' }], 'table2');
+    it("should work with manual next() calls", async () => {
+        const dataSource1 = createMockDataSource([{ id: 1, name: "Alice" }], "table1");
+        const dataSource2 = createMockDataSource([{ id: 2, name: "Bob" }], "table2");
         const cursor = (0, multi_cursors_1.queryMerge)([dataSource1, dataSource2]);
         const results = [];
         while (await cursor.next()) {
             results.push(cursor.value);
         }
-        expect(results.map(r => r?.id)).toEqual([1, 2]);
+        expect(results.map((r) => r?.id)).toEqual([1, 2]);
     });
 });
-describe('cursorMap', () => {
-    it('should map cursor values using synchronous function', async () => {
+describe("cursorMap", () => {
+    it("should map cursor values using synchronous function", async () => {
         const sourceCursor = createMockCursor([1, 2, 3, 4, 5]);
         const mappedCursor = (0, multi_cursors_1.cursorMap)(sourceCursor, (x) => x * 2);
         const results = [];
@@ -251,24 +259,24 @@ describe('cursorMap', () => {
         }
         expect(results).toEqual([2, 4, 6, 8, 10]);
     });
-    it('should map cursor values using async function', async () => {
-        const sourceCursor = createMockCursor(['a', 'b', 'c']);
+    it("should map cursor values using async function", async () => {
+        const sourceCursor = createMockCursor(["a", "b", "c"]);
         const mappedCursor = (0, multi_cursors_1.cursorMap)(sourceCursor, async (x) => {
             // Simulate async operation
-            await new Promise(resolve => setTimeout(resolve, 1));
+            await new Promise((resolve) => setTimeout(resolve, 1));
             return x.toUpperCase();
         });
         const results = [];
         for await (const item of mappedCursor) {
             results.push(item);
         }
-        expect(results).toEqual(['A', 'B', 'C']);
+        expect(results).toEqual(["A", "B", "C"]);
     });
-    it('should transform data types correctly', async () => {
+    it("should transform data types correctly", async () => {
         const sourceCursor = createMockCursor([
-            { id: 1, name: 'Alice', age: 25 },
-            { id: 2, name: 'Bob', age: 30 },
-            { id: 3, name: 'Charlie', age: 35 }
+            { id: 1, name: "Alice", age: 25 },
+            { id: 2, name: "Bob", age: 30 },
+            { id: 3, name: "Charlie", age: 35 },
         ]);
         const mappedCursor = (0, multi_cursors_1.cursorMap)(sourceCursor, (person) => `${person.name} is ${person.age} years old`);
         const results = [];
@@ -276,12 +284,12 @@ describe('cursorMap', () => {
             results.push(item);
         }
         expect(results).toEqual([
-            'Alice is 25 years old',
-            'Bob is 30 years old',
-            'Charlie is 35 years old'
+            "Alice is 25 years old",
+            "Bob is 30 years old",
+            "Charlie is 35 years old",
         ]);
     });
-    it('should handle empty cursors', async () => {
+    it("should handle empty cursors", async () => {
         const sourceCursor = createMockCursor([]);
         const mappedCursor = (0, multi_cursors_1.cursorMap)(sourceCursor, (x) => x * 2);
         const results = [];
@@ -290,7 +298,7 @@ describe('cursorMap', () => {
         }
         expect(results).toEqual([]);
     });
-    it('should work with manual next() calls', async () => {
+    it("should work with manual next() calls", async () => {
         const sourceCursor = createMockCursor([10, 20, 30]);
         const mappedCursor = (0, multi_cursors_1.cursorMap)(sourceCursor, (x) => x / 10);
         const results = [];
@@ -299,8 +307,8 @@ describe('cursorMap', () => {
         }
         expect(results).toEqual([1, 2, 3]);
     });
-    it('should maintain cursor.value correctly', async () => {
-        const sourceCursor = createMockCursor(['hello', 'world']);
+    it("should maintain cursor.value correctly", async () => {
+        const sourceCursor = createMockCursor(["hello", "world"]);
         const mappedCursor = (0, multi_cursors_1.cursorMap)(sourceCursor, (x) => x.length);
         // First item
         await mappedCursor.next();
@@ -313,11 +321,11 @@ describe('cursorMap', () => {
         expect(result).toBeNull();
         expect(mappedCursor.value).toBeNull();
     });
-    it('should handle async errors in map function', async () => {
+    it("should handle async errors in map function", async () => {
         const sourceCursor = createMockCursor([1, 2, 3]);
         const mappedCursor = (0, multi_cursors_1.cursorMap)(sourceCursor, async (x) => {
             if (x === 2) {
-                throw new Error('Test error');
+                throw new Error("Test error");
             }
             return x * 2;
         });
@@ -330,19 +338,19 @@ describe('cursorMap', () => {
         }
         catch (error) {
             errorCaught = true;
-            expect(error.message).toBe('Test error');
+            expect(error.message).toBe("Test error");
         }
         expect(errorCaught).toBe(true);
         expect(results).toEqual([2]); // Only first item before error
     });
-    it('should throw error when skipPast is used', async () => {
+    it("should throw error when skipPast is used", async () => {
         const sourceCursor = createMockCursor([1, 2, 3]);
         const mappedCursor = (0, multi_cursors_1.cursorMap)(sourceCursor, (x) => x * 2);
-        await expect(mappedCursor.next(4)).rejects.toThrow('skipPast is not supported for cursorMap since the mapped cursor has a different type than the source cursor');
+        await expect(mappedCursor.next(4)).rejects.toThrow("skipPast is not supported for cursorMap since the mapped cursor has a different type than the source cursor");
     });
 });
-describe('cursorFilter', () => {
-    it('should filter cursor values using synchronous predicate', async () => {
+describe("cursorFilter", () => {
+    it("should filter cursor values using synchronous predicate", async () => {
         const sourceCursor = createMockCursor([1, 2, 3, 4, 5, 6]);
         const filteredCursor = (0, multi_cursors_1.cursorFilter)(sourceCursor, (x) => x % 2 === 0);
         const results = [];
@@ -351,25 +359,25 @@ describe('cursorFilter', () => {
         }
         expect(results).toEqual([2, 4, 6]);
     });
-    it('should filter cursor values using async predicate', async () => {
-        const sourceCursor = createMockCursor(['apple', 'banana', 'cherry', 'date']);
+    it("should filter cursor values using async predicate", async () => {
+        const sourceCursor = createMockCursor(["apple", "banana", "cherry", "date"]);
         const filteredCursor = (0, multi_cursors_1.cursorFilter)(sourceCursor, async (x) => {
             // Simulate async operation
-            await new Promise(resolve => setTimeout(resolve, 1));
+            await new Promise((resolve) => setTimeout(resolve, 1));
             return x.length > 5;
         });
         const results = [];
         for await (const item of filteredCursor) {
             results.push(item);
         }
-        expect(results).toEqual(['banana', 'cherry']);
+        expect(results).toEqual(["banana", "cherry"]);
     });
-    it('should filter objects based on properties', async () => {
+    it("should filter objects based on properties", async () => {
         const sourceCursor = createMockCursor([
-            { id: 1, name: 'Alice', age: 25 },
-            { id: 2, name: 'Bob', age: 30 },
-            { id: 3, name: 'Charlie', age: 35 },
-            { id: 4, name: 'David', age: 20 }
+            { id: 1, name: "Alice", age: 25 },
+            { id: 2, name: "Bob", age: 30 },
+            { id: 3, name: "Charlie", age: 35 },
+            { id: 4, name: "David", age: 20 },
         ]);
         const filteredCursor = (0, multi_cursors_1.cursorFilter)(sourceCursor, (person) => person.age >= 30);
         const results = [];
@@ -377,11 +385,11 @@ describe('cursorFilter', () => {
             results.push(item);
         }
         expect(results).toEqual([
-            { id: 2, name: 'Bob', age: 30 },
-            { id: 3, name: 'Charlie', age: 35 }
+            { id: 2, name: "Bob", age: 30 },
+            { id: 3, name: "Charlie", age: 35 },
         ]);
     });
-    it('should handle empty cursors', async () => {
+    it("should handle empty cursors", async () => {
         const sourceCursor = createMockCursor([]);
         const filteredCursor = (0, multi_cursors_1.cursorFilter)(sourceCursor, (x) => x > 0);
         const results = [];
@@ -390,7 +398,7 @@ describe('cursorFilter', () => {
         }
         expect(results).toEqual([]);
     });
-    it('should handle cursors where no items match filter', async () => {
+    it("should handle cursors where no items match filter", async () => {
         const sourceCursor = createMockCursor([1, 2, 3, 4, 5]);
         const filteredCursor = (0, multi_cursors_1.cursorFilter)(sourceCursor, (x) => x > 10);
         const results = [];
@@ -399,7 +407,7 @@ describe('cursorFilter', () => {
         }
         expect(results).toEqual([]);
     });
-    it('should work with manual next() calls', async () => {
+    it("should work with manual next() calls", async () => {
         const sourceCursor = createMockCursor([10, 15, 20, 25, 30]);
         const filteredCursor = (0, multi_cursors_1.cursorFilter)(sourceCursor, (x) => x >= 20);
         const results = [];
@@ -408,33 +416,33 @@ describe('cursorFilter', () => {
         }
         expect(results).toEqual([20, 25, 30]);
     });
-    it('should maintain cursor.value correctly', async () => {
-        const sourceCursor = createMockCursor(['hello', 'hi', 'world', 'test']);
+    it("should maintain cursor.value correctly", async () => {
+        const sourceCursor = createMockCursor(["hello", "hi", "world", "test"]);
         const filteredCursor = (0, multi_cursors_1.cursorFilter)(sourceCursor, (x) => x.length > 3);
         // First item
         await filteredCursor.next();
-        expect(filteredCursor.value).toBe('hello');
-        // Second item  
+        expect(filteredCursor.value).toBe("hello");
+        // Second item
         await filteredCursor.next();
-        expect(filteredCursor.value).toBe('world');
+        expect(filteredCursor.value).toBe("world");
         // Third item
         await filteredCursor.next();
-        expect(filteredCursor.value).toBe('test');
+        expect(filteredCursor.value).toBe("test");
         // End of data
         const result = await filteredCursor.next();
         expect(result).toBeNull();
         expect(filteredCursor.value).toBeNull();
     });
-    it('should throw error when skipPast is used', async () => {
+    it("should throw error when skipPast is used", async () => {
         const sourceCursor = createMockCursor([1, 2, 3]);
         const filteredCursor = (0, multi_cursors_1.cursorFilter)(sourceCursor, (x) => x > 1);
-        await expect(filteredCursor.next(2)).rejects.toThrow('skipPast is not supported for cursorFilter since filtering changes the cursor iteration order');
+        await expect(filteredCursor.next(2)).rejects.toThrow("skipPast is not supported for cursorFilter since filtering changes the cursor iteration order");
     });
-    it('should handle async errors in filter function', async () => {
+    it("should handle async errors in filter function", async () => {
         const sourceCursor = createMockCursor([1, 2, 3]);
         const filteredCursor = (0, multi_cursors_1.cursorFilter)(sourceCursor, async (x) => {
             if (x === 2) {
-                throw new Error('Filter error');
+                throw new Error("Filter error");
             }
             return x > 0;
         });
@@ -447,7 +455,7 @@ describe('cursorFilter', () => {
         }
         catch (error) {
             errorCaught = true;
-            expect(error.message).toBe('Filter error');
+            expect(error.message).toBe("Filter error");
         }
         expect(errorCaught).toBe(true);
         expect(results).toEqual([1]); // Only first item before error

package/dist/data/orm/sql.data-source.d.ts

@@ -1,10 +1,10 @@
-import { z } from "zod";
-import { Emitter } from "../../events";
-import { FieldType, IField } from "../../types/field-type";
-import { DataFilter, ICursorIterable, IDataQueryParams, IDataSource } from "./data-query";
-import { ISqlDb } from "./sql-db";
-import { IDataChangedEvent } from "./subscribable.data-source";
-import { ITableMetaData } from "./types";
+import type { z } from "zod";
+import type { Emitter } from "../../events";
+import type { FieldType, IField } from "../../types/field-type";
+import { type DataFilter, type ICursorIterable, type IDataQueryParams, type IDataSource } from "./data-query";
+import type { ISqlDb } from "./sql-db";
+import type { IDataChangedEvent } from "./subscribable.data-source";
+import { type ITableMetaData } from "./types";
 export declare class SQLDataSource<T extends {
     [key: string]: any;
 }> implements IDataSource<T> {