@peers-app/peers-sdk 0.27.3 → 0.27.5

package/dist/data/orm/cursor.test.js

@@ -1,314 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const cursor_1 = require("./cursor");
-const data_query_1 = require("./data-query");
-const factory_1 = require("./factory");
-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("Cursor", () => {
-    describe("basic functionality", () => {
-        it("should wrap an ICursorIterable and implement the interface", async () => {
-            const mockCursor = createMockCursor([1, 2, 3]);
-            const cursor = new cursor_1.Cursor(mockCursor);
-            const results = [];
-            for await (const item of cursor) {
-                results.push(item);
-            }
-            expect(results).toEqual([1, 2, 3]);
-        });
-        it("should support manual next() calls", async () => {
-            const mockCursor = createMockCursor(["a", "b", "c"]);
-            const cursor = new cursor_1.Cursor(mockCursor);
-            const results = [];
-            while (await cursor.next()) {
-                results.push(cursor.value);
-            }
-            expect(results).toEqual(["a", "b", "c"]);
-        });
-        it("should maintain cursor.value correctly", async () => {
-            const mockCursor = createMockCursor([10, 20]);
-            const cursor = new cursor_1.Cursor(mockCursor);
-            expect(cursor.value).toBeNull();
-            await cursor.next();
-            expect(cursor.value).toBe(10);
-            await cursor.next();
-            expect(cursor.value).toBe(20);
-            const result = await cursor.next();
-            expect(result).toBeNull();
-            expect(cursor.value).toBeNull();
-        });
-    });
-    describe("static factory methods", () => {
-        it("should create cursor from ICursorIterable using from()", async () => {
-            const mockCursor = createMockCursor([1, 2, 3]);
-            const cursor = cursor_1.Cursor.from(mockCursor);
-            const results = [];
-            for await (const item of cursor) {
-                results.push(item);
-            }
-            expect(results).toEqual([1, 2, 3]);
-        });
-        it("should create union cursor using static union()", async () => {
-            const cursor1 = createMockCursor([1, 2]);
-            const cursor2 = createMockCursor([3, 4]);
-            const cursor3 = createMockCursor([5, 6]);
-            const unionCursor = cursor_1.Cursor.union(cursor1, cursor2, cursor3);
-            const results = [];
-            for await (const item of unionCursor) {
-                results.push(item);
-            }
-            expect(results).toEqual([1, 2, 3, 4, 5, 6]);
-        });
-        it("should handle mix of Cursor and ICursorIterable in static union()", async () => {
-            const cursor1 = new cursor_1.Cursor(createMockCursor([1, 2]));
-            const cursor2 = createMockCursor([3, 4]);
-            const unionCursor = cursor_1.Cursor.union(cursor1, cursor2);
-            const results = [];
-            for await (const item of unionCursor) {
-                results.push(item);
-            }
-            expect(results).toEqual([1, 2, 3, 4]);
-        });
-    });
-    describe("instance methods", () => {
-        it("should create union cursor using instance union()", async () => {
-            const cursor1 = new cursor_1.Cursor(createMockCursor([1, 2]));
-            const cursor2 = createMockCursor([3, 4]);
-            const cursor3 = new cursor_1.Cursor(createMockCursor([5, 6]));
-            const unionCursor = cursor1.union(cursor2, cursor3);
-            const results = [];
-            for await (const item of unionCursor) {
-                results.push(item);
-            }
-            expect(results).toEqual([1, 2, 3, 4, 5, 6]);
-        });
-        it("should map cursor values using instance map()", async () => {
-            const cursor = new cursor_1.Cursor(createMockCursor([1, 2, 3, 4, 5]));
-            const mappedCursor = cursor.map((x) => x * 2);
-            const results = [];
-            for await (const item of mappedCursor) {
-                results.push(item);
-            }
-            expect(results).toEqual([2, 4, 6, 8, 10]);
-        });
-        it("should support async mapping functions", async () => {
-            const cursor = new cursor_1.Cursor(createMockCursor(["hello", "world"]));
-            const mappedCursor = cursor.map(async (x) => {
-                await new Promise((resolve) => setTimeout(resolve, 1));
-                return x.toUpperCase();
-            });
-            const results = [];
-            for await (const item of mappedCursor) {
-                results.push(item);
-            }
-            expect(results).toEqual(["HELLO", "WORLD"]);
-        });
-        it("should support method chaining", async () => {
-            const cursor1 = new cursor_1.Cursor(createMockCursor([1, 2]));
-            const cursor2 = createMockCursor([3, 4]);
-            const result = cursor1
-                .union(cursor2)
-                .map((x) => x * 10)
-                .map((x) => `num: ${x}`);
-            const results = [];
-            for await (const item of result) {
-                results.push(item);
-            }
-            expect(results).toEqual(["num: 10", "num: 20", "num: 30", "num: 40"]);
-        });
-        it("should handle empty cursors in operations", async () => {
-            const cursor1 = new cursor_1.Cursor(createMockCursor([]));
-            const cursor2 = createMockCursor([1, 2]);
-            const unionCursor = cursor1.union(cursor2);
-            const mappedCursor = unionCursor.map((x) => x * 2);
-            const results = [];
-            for await (const item of mappedCursor) {
-                results.push(item);
-            }
-            expect(results).toEqual([2, 4]);
-        });
-    });
-    describe("error handling", () => {
-        it("should propagate skipPast errors from map()", async () => {
-            const cursor = new cursor_1.Cursor(createMockCursor([1, 2, 3]));
-            const mappedCursor = cursor.map((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");
-        });
-        it("should propagate async errors from mapping functions", async () => {
-            const cursor = new cursor_1.Cursor(createMockCursor([1, 2, 3]));
-            const mappedCursor = cursor.map(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
-        });
-    });
-    describe("static factory methods for data sources", () => {
-        it("should create cursor from single dataSource using fromDataSource", async () => {
-            const dataSource = (0, factory_1.arrayAsTable)([
-                { id: 1, name: "Alice" },
-                { id: 2, name: "Bob" },
-                { id: 3, name: "Charlie" },
-            ], { name: "users" });
-            const cursor = cursor_1.Cursor.fromDataSource(dataSource, {}, { sortBy: ["name"] });
-            const results = [];
-            for await (const item of cursor) {
-                results.push(item);
-            }
-            expect(results.map((r) => r.name)).toEqual(["Alice", "Bob", "Charlie"]);
-        });
-        it("should create cursor from multiple dataSources using fromDataSources", async () => {
-            const dataSource1 = (0, factory_1.arrayAsTable)([
-                { id: 1, name: "Alice" },
-                { id: 3, name: "Charlie" },
-            ], { name: "users1" });
-            const dataSource2 = (0, factory_1.arrayAsTable)([
-                { id: 2, name: "Bob" },
-                { id: 4, name: "David" },
-            ], { name: "users2" });
-            const cursor = cursor_1.Cursor.fromDataSources([dataSource1, dataSource2]);
-            const results = [];
-            for await (const item of cursor) {
-                results.push(item);
-            }
-            expect(results.map((r) => r.id)).toEqual([1, 2, 3, 4]);
-        });
-        it("should support filters and options with fromDataSource", async () => {
-            const dataSource = (0, factory_1.arrayAsTable)([
-                { id: 1, name: "Alice", age: 25 },
-                { id: 2, name: "Bob", age: 30 },
-                { id: 3, name: "Charlie", age: 35 },
-            ], { name: "users" });
-            const cursor = cursor_1.Cursor.fromDataSource(dataSource, { age: { $gte: 30 } }, { sortBy: ["name"] });
-            const results = [];
-            for await (const item of cursor) {
-                results.push(item);
-            }
-            // Should only get Bob and Charlie (age >= 30), sorted by name
-            expect(results.map((r) => r.name)).toEqual(["Bob", "Charlie"]);
-        });
-        it("should support filters and options with fromDataSources", async () => {
-            const dataSource1 = (0, factory_1.arrayAsTable)([
-                { id: 1, name: "Alice", age: 25 },
-                { id: 2, name: "Bob", age: 30 },
-            ], { name: "users1" });
-            const dataSource2 = (0, factory_1.arrayAsTable)([
-                { id: 3, name: "Charlie", age: 35 },
-                { id: 4, name: "David", age: 20 },
-            ], { name: "users2" });
-            const cursor = cursor_1.Cursor.fromDataSources([dataSource1, dataSource2], { age: { $gte: 25 } }, { sortBy: ["name"] });
-            const results = [];
-            for await (const item of cursor) {
-                results.push(item);
-            }
-            // Should get Alice, Bob, Charlie (age >= 25), sorted by name
-            expect(results.map((r) => r.name)).toEqual(["Alice", "Bob", "Charlie"]);
-        });
-        it("should work with method chaining after fromDataSource", async () => {
-            const dataSource = (0, factory_1.arrayAsTable)([
-                { id: 1, name: "Alice" },
-                { id: 2, name: "Bob" },
-            ], { name: "users" });
-            const cursor = cursor_1.Cursor.fromDataSource(dataSource).map((item) => item.name.toUpperCase());
-            const results = [];
-            for await (const item of cursor) {
-                results.push(item);
-            }
-            expect(results).toEqual(["ALICE", "BOB"]);
-        });
-        it("should filter cursor values using instance filter()", async () => {
-            const cursor = new cursor_1.Cursor(createMockCursor([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]));
-            const filteredCursor = cursor.filter((x) => x % 3 === 0);
-            const results = [];
-            for await (const item of filteredCursor) {
-                results.push(item);
-            }
-            expect(results).toEqual([3, 6, 9]);
-        });
-        it("should support async filter functions", async () => {
-            const cursor = new cursor_1.Cursor(createMockCursor(["apple", "banana", "cherry", "date", "elderberry"]));
-            const filteredCursor = cursor.filter(async (x) => {
-                await new Promise((resolve) => setTimeout(resolve, 1));
-                return x.startsWith("a") || x.startsWith("e");
-            });
-            const results = [];
-            for await (const item of filteredCursor) {
-                results.push(item);
-            }
-            expect(results).toEqual(["apple", "elderberry"]);
-        });
-        it("should support method chaining with filter", async () => {
-            const cursor = new cursor_1.Cursor(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 result = cursor
-                .filter((person) => person.age >= 25)
-                .map((person) => person.name.toUpperCase())
-                .filter((name) => name.includes("A"));
-            const results = [];
-            for await (const item of result) {
-                results.push(item);
-            }
-            expect(results).toEqual(["ALICE", "CHARLIE"]);
-        });
-        it("should handle empty results after filtering", async () => {
-            const cursor = new cursor_1.Cursor(createMockCursor([1, 2, 3, 4, 5]));
-            const filteredCursor = cursor.filter((x) => x > 10);
-            const results = [];
-            for await (const item of filteredCursor) {
-                results.push(item);
-            }
-            expect(results).toEqual([]);
-        });
-        it("should propagate skipPast errors from filter()", async () => {
-            const cursor = new cursor_1.Cursor(createMockCursor([1, 2, 3, 4, 5]));
-            const filteredCursor = cursor.filter((x) => x > 2);
-            await expect(filteredCursor.next(3)).rejects.toThrow("skipPast is not supported for cursorFilter since filtering changes the cursor iteration order");
-        });
-        it("should support complex method chaining with union, filter, and map", async () => {
-            const cursor1 = new cursor_1.Cursor(createMockCursor([1, 2, 3]));
-            const cursor2 = createMockCursor([4, 5, 6]);
-            const cursor3 = createMockCursor([7, 8, 9]);
-            const result = cursor1
-                .union(cursor2, cursor3)
-                .filter((x) => x % 2 === 1) // odd numbers
-                .map((x) => x * 10);
-            const results = [];
-            for await (const item of result) {
-                results.push(item);
-            }
-            expect(results).toEqual([10, 30, 50, 70, 90]);
-        });
-    });
-});

package/dist/data/orm/data-query.mongo.test.d.ts

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