@peers-app/peers-sdk 0.27.3 → 0.27.5

package/dist/data/orm/dependency-injection.test.js

@@ -1,171 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const zod_1 = require("zod");
-const data_context_1 = require("../../context/data-context");
-const field_type_1 = require("../../types/field-type");
-const _1 = require(".");
-describe("Dependency Injection Pattern", () => {
-    const testSchema = zod_1.z.object({
-        id: zod_1.z.string(),
-        name: zod_1.z.string(),
-    });
-    const testMetaData = {
-        name: "TestTable",
-        description: "Test table for DI pattern",
-        primaryKeyName: "id",
-        fields: [
-            { name: "id", type: field_type_1.FieldType.string, description: "ID field" },
-            { name: "name", type: field_type_1.FieldType.string, description: "Name field" },
-        ],
-    };
-    it("should create table using new DI constructor", () => {
-        // Create mock dependencies
-        const mockDeps = {
-            dataSource: {
-                tableName: "TestTable",
-                primaryKeyName: "id",
-                list: jest.fn().mockResolvedValue([]),
-                get: jest.fn().mockResolvedValue(null),
-                save: jest.fn().mockResolvedValue({}),
-                insert: jest.fn().mockResolvedValue({}),
-                update: jest.fn().mockResolvedValue({}),
-                delete: jest.fn().mockResolvedValue(undefined),
-            },
-            eventRegistry: {
-                getEmitter: jest.fn().mockReturnValue({
-                    event: { subscribe: jest.fn() },
-                    emit: jest.fn(),
-                }),
-            },
-        };
-        // Create table using new DI pattern
-        const table = new _1.Table(testMetaData, mockDeps);
-        // Verify table was created correctly
-        expect(table.tableName).toBe("TestTable");
-        expect(table.primaryKeyName).toBe("id");
-        // Verify schema works by parsing test data successfully
-        const testData = { id: "test-id", name: "test-name" };
-        expect(() => table.schema.parse(testData)).not.toThrow();
-        expect(table.metaData).toBe(testMetaData);
-        expect(table.dataSource).toBe(mockDeps.dataSource);
-    });
-    it("should allow easy custom table extension with DI pattern", () => {
-        // Example custom table class
-        class CustomTable extends _1.Table {
-            // Custom business method
-            async findByName(name) {
-                return this.list({ name });
-            }
-        }
-        const mockDeps = {
-            dataSource: {
-                tableName: "CustomTable",
-                primaryKeyName: "id",
-                list: jest.fn().mockResolvedValue([{ id: "1", name: "test" }]),
-                get: jest.fn(),
-                save: jest.fn(),
-                insert: jest.fn(),
-                update: jest.fn(),
-                delete: jest.fn(),
-            },
-            eventRegistry: {
-                getEmitter: jest.fn().mockReturnValue({
-                    event: { subscribe: jest.fn() },
-                    emit: jest.fn(),
-                }),
-            },
-        };
-        const customTable = new CustomTable(testMetaData, mockDeps);
-        // Verify custom table works
-        expect(customTable).toBeInstanceOf(_1.Table);
-        expect(customTable).toBeInstanceOf(CustomTable);
-        // Verify custom method exists
-        expect(typeof customTable.findByName).toBe("function");
-    });
-    it("should create table dependencies using DataContext factory method", () => {
-        // Create mock DataContext
-        const mockUserContext = {
-            userId: () => "test-user",
-            dataSourceFactory: jest.fn().mockReturnValue({
-                tableName: "TestTable",
-                primaryKeyName: "id",
-                list: jest.fn(),
-            }),
-        };
-        const dataContext = new data_context_1.DataContext(mockUserContext);
-        // Use factory method to create dependencies
-        const deps = dataContext.createTableDependencies(testMetaData, testSchema);
-        // Verify dependencies were created correctly
-        expect(deps.dataSource).toBeDefined();
-        expect(deps.eventRegistry).toBeDefined();
-        expect(deps.schema).toBe(testSchema); // Schema should be passed through when explicitly provided
-        expect(deps.eventRegistry).toBe(dataContext.eventRegistry);
-    });
-    it("should compute schema from metaData when not provided in dependencies", () => {
-        // Create mock dependencies without schema
-        const mockDeps = {
-            dataSource: {
-                tableName: "TestTable",
-                primaryKeyName: "id",
-                list: jest.fn().mockResolvedValue([]),
-                get: jest.fn().mockResolvedValue(null),
-                save: jest.fn().mockResolvedValue({}),
-                insert: jest.fn().mockResolvedValue({}),
-                update: jest.fn().mockResolvedValue({}),
-                delete: jest.fn().mockResolvedValue(undefined),
-            },
-            eventRegistry: {
-                getEmitter: jest.fn().mockReturnValue({
-                    event: { subscribe: jest.fn() },
-                    emit: jest.fn(),
-                }),
-            },
-            // Note: no schema provided
-        };
-        // Create table - schema should be computed from metaData.fields
-        const table = new _1.Table(testMetaData, mockDeps);
-        // Verify schema was computed correctly by testing it works
-        const testData = { id: "test-id", name: "test-name" };
-        expect(() => table.schema.parse(testData)).not.toThrow();
-    });
-    it("should create tables using DataContext convenience method", () => {
-        // Create mock DataContext
-        const mockUserContext = {
-            userId: () => "test-user",
-            dataSourceFactory: jest.fn().mockReturnValue({
-                tableName: "TestTable",
-                primaryKeyName: "id",
-                list: jest.fn(),
-            }),
-        };
-        const dataContext = new data_context_1.DataContext(mockUserContext);
-        // Use convenience method to create table
-        const table = dataContext.createTable(testMetaData, testSchema);
-        // Verify table was created correctly
-        expect(table).toBeInstanceOf(_1.Table);
-        expect(table.tableName).toBe("TestTable");
-        // Table merges fields-derived schema with code schema, so it's not the same reference
-        const testData = { id: "test-id", name: "test-name" };
-        expect(() => table.schema.parse(testData)).not.toThrow();
-    });
-    it("should create tables through TableFactory using new DI pattern internally", () => {
-        // Create mock DataContext
-        const mockUserContext = {
-            userId: () => "test-user",
-            dataSourceFactory: jest.fn().mockReturnValue({
-                tableName: "TestTable",
-                primaryKeyName: "id",
-                list: jest.fn(),
-            }),
-        };
-        const dataContext = new data_context_1.DataContext(mockUserContext);
-        // Use TableFactory (which should internally use DI pattern now)
-        const table = dataContext.tableContainer.getTable(testMetaData, testSchema);
-        // Verify table was created correctly through TableFactory
-        expect(table).toBeInstanceOf(_1.Table);
-        expect(table.tableName).toBe("TestTable");
-        // Table merges fields-derived schema with code schema, so it's not the same reference
-        expect(() => table.schema.parse({ id: "test-id", name: "test-name" })).not.toThrow();
-        expect(table.metaData).toBe(testMetaData);
-    });
-});

package/dist/data/orm/event-registry.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/data/orm/event-registry.test.js

@@ -1,44 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const event_registry_1 = require("./event-registry");
-describe("EventRegistry", () => {
-    let registry;
-    beforeEach(() => {
-        const mockDataContext = {
-            dataContextId: "test-context",
-        };
-        registry = new event_registry_1.EventRegistry(mockDataContext);
-    });
-    it("should return the same emitter for the same event name", () => {
-        const emitter1 = registry.getEmitter("test-event");
-        const emitter2 = registry.getEmitter("test-event");
-        expect(emitter1).toBe(emitter2);
-        expect(registry.getEmitterCount()).toBe(1);
-    });
-    it("should return different emitters for different event names", () => {
-        const emitter1 = registry.getEmitter("event-1");
-        const emitter2 = registry.getEmitter("event-2");
-        expect(emitter1).not.toBe(emitter2);
-        expect(registry.getEmitterCount()).toBe(2);
-    });
-    it("should clear all emitters", () => {
-        registry.getEmitter("event-1");
-        registry.getEmitter("event-2");
-        expect(registry.getEmitterCount()).toBe(2);
-        registry.clear();
-        expect(registry.getEmitterCount()).toBe(0);
-    });
-    it("should handle event emission and subscription across shared emitters", async () => {
-        const emitter1 = registry.getEmitter("shared-event");
-        const emitter2 = registry.getEmitter("shared-event");
-        // They should be the same instance
-        expect(emitter1).toBe(emitter2);
-        // Test event flow
-        let receivedData;
-        emitter1.event.subscribe((data) => {
-            receivedData = data;
-        });
-        await emitter2.emit("test-data");
-        expect(receivedData).toBe("test-data");
-    });
-});

package/dist/data/orm/multi-cursors.test.d.ts

@@ -1 +0,0 @@
-export {};

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

@@ -1,463 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const field_type_1 = require("../../types/field-type");
-const data_query_1 = require("./data-query");
-const factory_1 = require("./factory");
-const multi_cursors_1 = require("./multi-cursors");
-function createMockCursor(items) {
-    let index = 0;
-    const cursor = {
-        value: null,
-        next: async (_skipPast) => {
-            if (index >= items.length) {
-                cursor.value = null;
-                return null;
-            }
-            cursor.value = items[index];
-            index++;
-            return cursor.value;
-        },
-    };
-    return (0, data_query_1.iterableCursor)(cursor);
-}
-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]);
-        const results = [];
-        for await (const item of unionCursor) {
-            results.push(item);
-        }
-        expect(results).toEqual([1, 2, 3, 4, 5, 6]);
-    });
-    it("should handle empty cursors gracefully", async () => {
-        const cursor1 = createMockCursor([1, 2]);
-        const cursor2 = createMockCursor([]);
-        const cursor3 = createMockCursor([3, 4]);
-        const unionCursor = (0, multi_cursors_1.cursorUnion)([cursor1, cursor2, cursor3]);
-        const results = [];
-        for await (const item of unionCursor) {
-            results.push(item);
-        }
-        expect(results).toEqual([1, 2, 3, 4]);
-    });
-    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]);
-        const results = [];
-        for await (const item of unionCursor) {
-            results.push(item);
-        }
-        expect(results).toEqual([]);
-    });
-    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"]);
-    });
-    it("should work with no cursors", async () => {
-        const unionCursor = (0, multi_cursors_1.cursorUnion)([]);
-        const results = [];
-        for await (const item of unionCursor) {
-            results.push(item);
-        }
-        expect(results).toEqual([]);
-    });
-    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]);
-        const results = [];
-        while (await unionCursor.next()) {
-            results.push(unionCursor.value);
-        }
-        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" }]);
-        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" },
-        ]);
-    });
-    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");
-        // Second item
-        await unionCursor.next();
-        expect(unionCursor.value).toBe("second");
-        // Third item (from second cursor)
-        await unionCursor.next();
-        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") {
-    return (0, factory_1.arrayAsTable)(items, {
-        name: tableName,
-        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 };
-        // 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
-    });
-    it("should handle null/undefined values like SQL", () => {
-        const a = { id: 1, name: null };
-        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)
-    });
-});
-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");
-        const dataSource2 = createMockDataSource([
-            { 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",
-        ]);
-    });
-    it("should handle empty data sources", async () => {
-        const dataSource1 = (0, factory_1.arrayAsTable)([], {
-            name: "table1",
-            primaryKeyName: "id",
-            fields: [
-                { 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 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" }]);
-    });
-    it("should handle no data sources", async () => {
-        const cursor = (0, multi_cursors_1.queryMerge)([]);
-        const results = [];
-        for await (const item of cursor) {
-            results.push(item);
-        }
-        expect(results).toEqual([]);
-    });
-    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");
-        const dataSource2 = createMockDataSource([
-            { 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 results = [];
-        for await (const item of cursor) {
-            results.push(item);
-        }
-        expect(results.map((r) => r.name)).toEqual(["Alice", "Bob", "Charlie", "David"]);
-    });
-    it("should work with single data source", async () => {
-        const dataSource = createMockDataSource([
-            { 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]);
-    });
-    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]);
-    });
-});
-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 = [];
-        for await (const item of mappedCursor) {
-            results.push(item);
-        }
-        expect(results).toEqual([2, 4, 6, 8, 10]);
-    });
-    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));
-            return x.toUpperCase();
-        });
-        const results = [];
-        for await (const item of mappedCursor) {
-            results.push(item);
-        }
-        expect(results).toEqual(["A", "B", "C"]);
-    });
-    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 },
-        ]);
-        const mappedCursor = (0, multi_cursors_1.cursorMap)(sourceCursor, (person) => `${person.name} is ${person.age} years old`);
-        const results = [];
-        for await (const item of mappedCursor) {
-            results.push(item);
-        }
-        expect(results).toEqual([
-            "Alice is 25 years old",
-            "Bob is 30 years old",
-            "Charlie is 35 years old",
-        ]);
-    });
-    it("should handle empty cursors", async () => {
-        const sourceCursor = createMockCursor([]);
-        const mappedCursor = (0, multi_cursors_1.cursorMap)(sourceCursor, (x) => x * 2);
-        const results = [];
-        for await (const item of mappedCursor) {
-            results.push(item);
-        }
-        expect(results).toEqual([]);
-    });
-    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 = [];
-        while (await mappedCursor.next()) {
-            results.push(mappedCursor.value);
-        }
-        expect(results).toEqual([1, 2, 3]);
-    });
-    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();
-        expect(mappedCursor.value).toBe(5);
-        // Second item
-        await mappedCursor.next();
-        expect(mappedCursor.value).toBe(5);
-        // End of data
-        const result = await mappedCursor.next();
-        expect(result).toBeNull();
-        expect(mappedCursor.value).toBeNull();
-    });
-    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");
-            }
-            return x * 2;
-        });
-        const results = [];
-        let errorCaught = false;
-        try {
-            for await (const item of mappedCursor) {
-                results.push(item);
-            }
-        }
-        catch (error) {
-            errorCaught = true;
-            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 () => {
-        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");
-    });
-});
-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 = [];
-        for await (const item of filteredCursor) {
-            results.push(item);
-        }
-        expect(results).toEqual([2, 4, 6]);
-    });
-    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));
-            return x.length > 5;
-        });
-        const results = [];
-        for await (const item of filteredCursor) {
-            results.push(item);
-        }
-        expect(results).toEqual(["banana", "cherry"]);
-    });
-    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 },
-        ]);
-        const filteredCursor = (0, multi_cursors_1.cursorFilter)(sourceCursor, (person) => person.age >= 30);
-        const results = [];
-        for await (const item of filteredCursor) {
-            results.push(item);
-        }
-        expect(results).toEqual([
-            { id: 2, name: "Bob", age: 30 },
-            { id: 3, name: "Charlie", age: 35 },
-        ]);
-    });
-    it("should handle empty cursors", async () => {
-        const sourceCursor = createMockCursor([]);
-        const filteredCursor = (0, multi_cursors_1.cursorFilter)(sourceCursor, (x) => x > 0);
-        const results = [];
-        for await (const item of filteredCursor) {
-            results.push(item);
-        }
-        expect(results).toEqual([]);
-    });
-    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 = [];
-        for await (const item of filteredCursor) {
-            results.push(item);
-        }
-        expect(results).toEqual([]);
-    });
-    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 = [];
-        while (await filteredCursor.next()) {
-            results.push(filteredCursor.value);
-        }
-        expect(results).toEqual([20, 25, 30]);
-    });
-    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
-        await filteredCursor.next();
-        expect(filteredCursor.value).toBe("world");
-        // Third item
-        await filteredCursor.next();
-        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 () => {
-        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");
-    });
-    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");
-            }
-            return x > 0;
-        });
-        const results = [];
-        let errorCaught = false;
-        try {
-            for await (const item of filteredCursor) {
-                results.push(item);
-            }
-        }
-        catch (error) {
-            errorCaught = true;
-            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.test.d.ts

@@ -1 +0,0 @@
-import "../../index";