@peers-app/peers-sdk 0.27.2 → 0.27.4

package/dist/device/device-election.test.js

@@ -1,516 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const lodash_1 = require("lodash");
-const utils_1 = require("../utils");
-const device_election_1 = require("./device-election");
-describe("device-election", () => {
-    const createConnection = (deviceId, latencyMs = 10, errorRate = 0.001) => ({
-        deviceId,
-        latencyMs,
-        errorRate,
-        timestampLastApplied: Date.now(),
-    });
-    const createNetworkInfo = (deviceId, connections = [], preferredDeviceIds = [], connectionSlotsAvailable = 10) => ({
-        deviceId,
-        timestampLastApplied: Date.now(),
-        connections,
-        preferredDeviceIds,
-        cpuPercent: 0,
-        memPercent: 0,
-        connectionSlotsAvailable,
-    });
-    describe("electDevices", () => {
-        it("should return empty arrays when there are no connections", () => {
-            const deviceId = (0, utils_1.newid)();
-            const result = (0, device_election_1.electDevices)({
-                deviceId,
-                myConnections: [],
-                allNetworkInfo: [],
-            });
-            expect(result.preferredDeviceIds).toEqual([]);
-            expect(result.preferredByDeviceIds).toEqual([]);
-        });
-        it("should elect devices that provide connections to unconnected devices", () => {
-            const myDeviceId = (0, utils_1.newid)();
-            const device1 = (0, utils_1.newid)();
-            const device2 = (0, utils_1.newid)();
-            const device3 = (0, utils_1.newid)();
-            const myConnection1 = createConnection(device1);
-            const myConnection2 = createConnection(device2);
-            const networkInfo1 = createNetworkInfo(device1, [
-                createConnection(device2),
-                createConnection(device3),
-            ]);
-            const networkInfo2 = createNetworkInfo(device2, [createConnection(device1)]);
-            const result = (0, device_election_1.electDevices)({
-                deviceId: myDeviceId,
-                myConnections: [myConnection1, myConnection2],
-                allNetworkInfo: [networkInfo1, networkInfo2],
-            });
-            // device1 should be preferred because it connects to device3 (which we're not connected to)
-            // device2 should be preferred because it connects to device1 (which we're connected to, but still useful)
-            expect(result.preferredDeviceIds.length).toBeGreaterThan(0);
-            expect(result.preferredDeviceIds).toContain(device1);
-        });
-        it("should prefer devices that are preferred by other devices", () => {
-            const myDeviceId = (0, utils_1.newid)();
-            const device1 = (0, utils_1.newid)();
-            const device2 = (0, utils_1.newid)();
-            const myConnection1 = createConnection(device1);
-            const myConnection2 = createConnection(device2);
-            // device1 is preferred by device2
-            const networkInfo1 = createNetworkInfo(device1, [], []);
-            const networkInfo2 = createNetworkInfo(device2, [], [device1]);
-            const result = (0, device_election_1.electDevices)({
-                deviceId: myDeviceId,
-                myConnections: [myConnection1, myConnection2],
-                allNetworkInfo: [networkInfo1, networkInfo2],
-            });
-            expect(result.preferredDeviceIds).toContain(device1);
-        });
-        it("should track which devices prefer me", () => {
-            const myDeviceId = (0, utils_1.newid)();
-            const device1 = (0, utils_1.newid)();
-            const device2 = (0, utils_1.newid)();
-            const myConnection1 = createConnection(device1);
-            const myConnection2 = createConnection(device2);
-            // device1 and device2 both prefer myDeviceId
-            const networkInfo1 = createNetworkInfo(device1, [], [myDeviceId]);
-            const networkInfo2 = createNetworkInfo(device2, [], [myDeviceId]);
-            const result = (0, device_election_1.electDevices)({
-                deviceId: myDeviceId,
-                myConnections: [myConnection1, myConnection2],
-                allNetworkInfo: [networkInfo1, networkInfo2],
-            });
-            expect(result.preferredByDeviceIds).toContain(device1);
-            expect(result.preferredByDeviceIds).toContain(device2);
-        });
-        it("should prefer connections with lower latency and error rate", () => {
-            const myDeviceId = (0, utils_1.newid)();
-            const device1 = (0, utils_1.newid)();
-            const device2 = (0, utils_1.newid)();
-            const device3 = (0, utils_1.newid)();
-            // device1 has better connection quality
-            const myConnection1 = createConnection(device1, 5, 0.0001);
-            // device2 has worse connection quality
-            const myConnection2 = createConnection(device2, 50, 0.01);
-            const networkInfo1 = createNetworkInfo(device1, [createConnection(device3)]);
-            const networkInfo2 = createNetworkInfo(device2, [createConnection(device3)]);
-            const result = (0, device_election_1.electDevices)({
-                deviceId: myDeviceId,
-                myConnections: [myConnection1, myConnection2],
-                allNetworkInfo: [networkInfo1, networkInfo2],
-            });
-            // device1 should be preferred due to better connection quality
-            expect(result.preferredDeviceIds[0]).toBe(device1);
-        });
-        it("should prefer devices that connect to more unconnected devices", () => {
-            const myDeviceId = (0, utils_1.newid)();
-            const device1 = (0, utils_1.newid)();
-            const device2 = (0, utils_1.newid)();
-            const device3 = (0, utils_1.newid)();
-            const device4 = (0, utils_1.newid)();
-            const myConnection1 = createConnection(device1);
-            const myConnection2 = createConnection(device2);
-            // device1 connects to device3 and device4
-            const networkInfo1 = createNetworkInfo(device1, [
-                createConnection(device3),
-                createConnection(device4),
-            ]);
-            // device2 only connects to device3
-            const networkInfo2 = createNetworkInfo(device2, [createConnection(device3)]);
-            const result = (0, device_election_1.electDevices)({
-                deviceId: myDeviceId,
-                myConnections: [myConnection1, myConnection2],
-                allNetworkInfo: [networkInfo1, networkInfo2],
-            });
-            // device1 should be preferred because it connects to more devices
-            expect(result.preferredDeviceIds[0]).toBe(device1);
-        });
-        it("should exclude my own deviceId from preferred devices", () => {
-            const myDeviceId = (0, utils_1.newid)();
-            const device1 = (0, utils_1.newid)();
-            const myConnection1 = createConnection(device1);
-            const networkInfo1 = createNetworkInfo(device1, []);
-            // Include network info for myself (shouldn't happen in practice, but test edge case)
-            const myNetworkInfo = createNetworkInfo(myDeviceId, []);
-            const result = (0, device_election_1.electDevices)({
-                deviceId: myDeviceId,
-                myConnections: [myConnection1],
-                allNetworkInfo: [networkInfo1, myNetworkInfo],
-            });
-            expect(result.preferredDeviceIds).not.toContain(myDeviceId);
-        });
-        it("should handle devices with limited connection slots", () => {
-            const myDeviceId = (0, utils_1.newid)();
-            const device1 = (0, utils_1.newid)();
-            const device2 = (0, utils_1.newid)();
-            const myConnection1 = createConnection(device1);
-            const myConnection2 = createConnection(device2);
-            // device1 is nearing max connections
-            const networkInfo1 = createNetworkInfo(device1, [], [], 2);
-            // device2 has plenty of slots
-            const networkInfo2 = createNetworkInfo(device2, [], [], 10);
-            const result = (0, device_election_1.electDevices)({
-                deviceId: myDeviceId,
-                myConnections: [myConnection1, myConnection2],
-                allNetworkInfo: [networkInfo1, networkInfo2],
-            });
-            // device2 should be preferred due to more available slots
-            expect(result.preferredDeviceIds[0]).toBe(device2);
-        });
-        it("should handle bidirectional connections preference", () => {
-            const myDeviceId = (0, utils_1.newid)();
-            const device1 = (0, utils_1.newid)();
-            const device2 = (0, utils_1.newid)();
-            const myConnection1 = createConnection(device1);
-            const myConnection2 = createConnection(device2);
-            // device1 has a connection back to me
-            const networkInfo1 = createNetworkInfo(device1, [createConnection(myDeviceId)]);
-            // device2 doesn't have a connection back to me
-            const networkInfo2 = createNetworkInfo(device2, []);
-            const result = (0, device_election_1.electDevices)({
-                deviceId: myDeviceId,
-                myConnections: [myConnection1, myConnection2],
-                allNetworkInfo: [networkInfo1, networkInfo2],
-            });
-            // device1 should be preferred due to bidirectional connection
-            expect(result.preferredDeviceIds[0]).toBe(device1);
-        });
-    });
-    describe("getLeastPreferredConnection", () => {
-        it("should return undefined when there are no connections", () => {
-            const result = (0, device_election_1.getLeastPreferredConnection)({
-                connections: [],
-                preferredDeviceIds: [],
-                preferredByDeviceIds: [],
-            });
-            expect(result).toBeUndefined();
-        });
-        it("should prefer non-critical connections first", () => {
-            const device1 = (0, utils_1.newid)();
-            const device2 = (0, utils_1.newid)();
-            const device3 = (0, utils_1.newid)();
-            const connections = [
-                { ...createConnection(device1), groups: ["group1"] },
-                { ...createConnection(device2), groups: ["group1", "group2"] },
-                { ...createConnection(device3), groups: ["group1"] },
-            ];
-            // device1 is critical, device2 and device3 are not
-            const result = (0, device_election_1.getLeastPreferredConnection)({
-                connections,
-                preferredDeviceIds: [device1],
-                preferredByDeviceIds: [],
-            });
-            // Should return one of the non-critical connections (device2 or device3)
-            expect(result).toBeDefined();
-            expect(result?.deviceId).not.toBe(device1);
-        });
-        it("should prefer connections that are not critical to me and I'm not critical to them", () => {
-            const device1 = (0, utils_1.newid)();
-            const device2 = (0, utils_1.newid)();
-            const device3 = (0, utils_1.newid)();
-            const connections = [
-                { ...createConnection(device1), groups: ["group1"] },
-                { ...createConnection(device2), groups: ["group1"] },
-                { ...createConnection(device3), groups: ["group1"] },
-            ];
-            // device1 is critical to me, device2 is critical to them, device3 is neither
-            const result = (0, device_election_1.getLeastPreferredConnection)({
-                connections,
-                preferredDeviceIds: [device1],
-                preferredByDeviceIds: [device2],
-            });
-            // Should prefer device3
-            expect(result?.deviceId).toBe(device3);
-        });
-        it("should fall back to non-critical-to-me connections if no ideal candidates", () => {
-            const device1 = (0, utils_1.newid)();
-            const device2 = (0, utils_1.newid)();
-            const connections = [
-                { ...createConnection(device1), groups: ["group1"] },
-                { ...createConnection(device2), groups: ["group1"] },
-            ];
-            // device1 is critical to me, device2 is critical to them
-            const result = (0, device_election_1.getLeastPreferredConnection)({
-                connections,
-                preferredDeviceIds: [device1],
-                preferredByDeviceIds: [device2],
-            });
-            // Should prefer device2 (not critical to me) over device1
-            expect(result?.deviceId).toBe(device2);
-        });
-        it("should prefer connections with higher latency and error rate", () => {
-            const device1 = (0, utils_1.newid)();
-            const device2 = (0, utils_1.newid)();
-            const device3 = (0, utils_1.newid)();
-            const connections = [
-                { ...createConnection(device1, 10, 0.001), groups: [] },
-                { ...createConnection(device2, 50, 0.01), groups: [] },
-                { ...createConnection(device3, 100, 0.1), groups: [] },
-            ];
-            const result = (0, device_election_1.getLeastPreferredConnection)({
-                connections,
-                preferredDeviceIds: [],
-                preferredByDeviceIds: [],
-            });
-            // Should prefer device3 (worst connection quality)
-            expect(result?.deviceId).toBe(device3);
-        });
-        it("should prefer connections with fewer groups", () => {
-            const device1 = (0, utils_1.newid)();
-            const device2 = (0, utils_1.newid)();
-            const device3 = (0, utils_1.newid)();
-            const connections = [
-                { ...createConnection(device1), groups: ["group1", "group2", "group3"] },
-                { ...createConnection(device2), groups: ["group1", "group2"] },
-                { ...createConnection(device3), groups: ["group1"] },
-            ];
-            const result = (0, device_election_1.getLeastPreferredConnection)({
-                connections,
-                preferredDeviceIds: [],
-                preferredByDeviceIds: [],
-            });
-            // Should prefer device3 (fewest groups)
-            expect(result?.deviceId).toBe(device3);
-        });
-        it("should consider all connections if all are critical", () => {
-            const device1 = (0, utils_1.newid)();
-            const device2 = (0, utils_1.newid)();
-            const connections = [
-                { ...createConnection(device1, 10, 0.001), groups: ["group1"] },
-                { ...createConnection(device2, 100, 0.1), groups: [] },
-            ];
-            // Both are critical
-            const result = (0, device_election_1.getLeastPreferredConnection)({
-                connections,
-                preferredDeviceIds: [device1, device2],
-                preferredByDeviceIds: [device1, device2],
-            });
-            // Should still return one (device2 has worse quality and fewer groups)
-            expect(result?.deviceId).toBe(device2);
-        });
-        it("should randomize order before sorting to avoid bias", () => {
-            const device1 = (0, utils_1.newid)();
-            const device2 = (0, utils_1.newid)();
-            const device3 = (0, utils_1.newid)();
-            const connections = [
-                { ...createConnection(device1), groups: [] },
-                { ...createConnection(device2), groups: [] },
-                { ...createConnection(device3), groups: [] },
-            ];
-            // All have same characteristics, so result should be one of them
-            const result = (0, device_election_1.getLeastPreferredConnection)({
-                connections,
-                preferredDeviceIds: [],
-                preferredByDeviceIds: [],
-            });
-            expect(result).toBeDefined();
-            expect([device1, device2, device3]).toContain(result?.deviceId);
-        });
-        describe("alternativeRoutes", () => {
-            it("never sheds a device whose only known route is through us when others have alternatives", () => {
-                const stranded = (0, utils_1.newid)();
-                const others = [(0, utils_1.newid)(), (0, utils_1.newid)(), (0, utils_1.newid)()];
-                const connections = [
-                    // worst latency and most groups would normally make this the victim
-                    { ...createConnection(stranded, 900, 0.5), groups: ["g"], alternativeRoutes: 0 },
-                    ...others.map((id) => ({
-                        ...createConnection(id, 5, 0.001),
-                        groups: ["g", "h"],
-                        alternativeRoutes: 3,
-                    })),
-                ];
-                for (let i = 0; i < 20; i++) {
-                    const result = (0, device_election_1.getLeastPreferredConnection)({
-                        connections: (0, lodash_1.shuffle)(connections),
-                        preferredDeviceIds: [],
-                        preferredByDeviceIds: [],
-                    });
-                    expect(result).toBeDefined();
-                    expect(result?.deviceId).not.toBe(stranded);
-                    expect(others).toContain(result?.deviceId);
-                }
-            });
-            it("falls back to the usual ordering when no candidate is known to have alternatives", () => {
-                const device1 = (0, utils_1.newid)();
-                const device2 = (0, utils_1.newid)();
-                const connections = [
-                    { ...createConnection(device1, 10, 0.001), groups: ["g"], alternativeRoutes: 0 },
-                    { ...createConnection(device2, 500, 0.5), groups: ["g"], alternativeRoutes: 0 },
-                ];
-                const result = (0, device_election_1.getLeastPreferredConnection)({
-                    connections,
-                    preferredDeviceIds: [],
-                    preferredByDeviceIds: [],
-                });
-                expect(result?.deviceId).toBe(device2);
-            });
-            it("treats unknown topology as neither protected nor preferred", () => {
-                const unknown = (0, utils_1.newid)();
-                const stranded = (0, utils_1.newid)();
-                const connected = (0, utils_1.newid)();
-                const connections = [
-                    { ...createConnection(unknown, 500, 0.5), groups: ["g"] },
-                    { ...createConnection(stranded, 10, 0.001), groups: ["g"], alternativeRoutes: 0 },
-                    { ...createConnection(connected, 10, 0.001), groups: ["g"], alternativeRoutes: 2 },
-                ];
-                for (let i = 0; i < 20; i++) {
-                    const result = (0, device_election_1.getLeastPreferredConnection)({
-                        connections: (0, lodash_1.shuffle)(connections),
-                        preferredDeviceIds: [],
-                        preferredByDeviceIds: [],
-                    });
-                    // the stranded device is excluded; unknown stays in the pool and loses on latency
-                    expect(result?.deviceId).toBe(unknown);
-                }
-            });
-            it("still respects preference tiers before route protection", () => {
-                const stranded = (0, utils_1.newid)();
-                const preferred = (0, utils_1.newid)();
-                const connections = [
-                    { ...createConnection(stranded), groups: ["g"], alternativeRoutes: 0 },
-                    { ...createConnection(preferred), groups: ["g"], alternativeRoutes: 4 },
-                ];
-                // the only non-preferred candidate is the stranded one, so the tier leaves just it
-                const result = (0, device_election_1.getLeastPreferredConnection)({
-                    connections,
-                    preferredDeviceIds: [preferred],
-                    preferredByDeviceIds: [],
-                });
-                expect(result?.deviceId).toBe(stranded);
-            });
-        });
-    });
-    describe("Network simulations", () => {
-        it.skip("should work as connections grow", () => {
-            const MAX_CONNECTIONS = 100;
-            const groupId = (0, utils_1.newid)();
-            const deviceInfos = [];
-            function addDevice() {
-                const newDevice = {
-                    deviceId: (0, utils_1.newid)(),
-                    connections: [],
-                    preferredDeviceIds: [],
-                    preferredByDeviceIds: [],
-                };
-                deviceInfos.push(newDevice);
-            }
-            function _removeDevice(d) {
-                deviceInfos.splice(deviceInfos.indexOf(d), 1);
-                d.connections.forEach((c) => {
-                    const d2 = deviceInfos.find((d2) => d2.deviceId === c.deviceId);
-                    if (d2) {
-                        disconnectDevices(d, d2);
-                    }
-                });
-            }
-            function connectDevices(d1, d2) {
-                // same device
-                if (d1.deviceId === d2.deviceId) {
-                    return;
-                }
-                // already connected
-                if (d1.connections.some((c) => c.deviceId === d2.deviceId)) {
-                    return;
-                }
-                d1.connections.push({
-                    deviceId: d2.deviceId,
-                    errorRate: 0,
-                    latencyMs: 30,
-                    timestampLastApplied: 0,
-                });
-                d2.connections.push({
-                    deviceId: d1.deviceId,
-                    errorRate: 0,
-                    latencyMs: 30,
-                    timestampLastApplied: 0,
-                });
-            }
-            function disconnectDevices(d1, d2) {
-                d1.connections = d1.connections.filter((c) => c.deviceId !== d2.deviceId);
-                d2.connections = d2.connections.filter((c) => c.deviceId !== d1.deviceId);
-                d1.preferredByDeviceIds = d1.preferredByDeviceIds.filter((id) => id !== d2.deviceId);
-                d2.preferredByDeviceIds = d2.preferredByDeviceIds.filter((id) => id !== d1.deviceId);
-                d1.preferredDeviceIds = d1.preferredDeviceIds.filter((id) => id !== d2.deviceId);
-                d2.preferredDeviceIds = d2.preferredDeviceIds.filter((id) => id !== d1.deviceId);
-            }
-            // pre-populate with devices
-            Array(25)
-                .fill(undefined)
-                .forEach(() => {
-                addDevice();
-            });
-            const totalTicks = 200;
-            for (let tick = 0; tick < totalTicks; tick++) {
-                addDevice();
-                for (const device of [...deviceInfos]) {
-                    // // randomly remove
-                    // if (Math.random() < 0.01) {
-                    //   removeDevice(device);
-                    //   continue;
-                    // }
-                    // // randomly disconnect
-                    // if (Math.random() < 0.1) {
-                    //   const disconnect =
-                    //   disconnectDevices()
-                    // }
-                    // simulate a device wanting to maintain a "well connected" network
-                    while (device.connections.length < 25) {
-                        const otherPreferredIds = device.connections.flatMap((c) => deviceInfos.find((d) => d.deviceId === c.deviceId)?.preferredDeviceIds ?? []);
-                        const newDeviceId = otherPreferredIds.find((deviceId) => !device.connections.some((c) => c.deviceId === deviceId) &&
-                            deviceId !== device.deviceId);
-                        const newDevice = deviceInfos.find((d) => d.deviceId === newDeviceId);
-                        if (newDevice) {
-                            connectDevices(device, newDevice);
-                        }
-                        else {
-                            const unconnectedDevices = deviceInfos.filter((d) => !device.connections.some((c) => c.deviceId === d.deviceId));
-                            connectDevices(device, (0, lodash_1.shuffle)(unconnectedDevices)[0]);
-                        }
-                    }
-                    // do elections
-                    const networkInfo = device.connections.map((c) => {
-                        const remoteDevice = deviceInfos.find((d) => d.deviceId === c.deviceId);
-                        return {
-                            deviceId: remoteDevice.deviceId,
-                            connections: [...remoteDevice.connections],
-                            connectionSlotsAvailable: MAX_CONNECTIONS - remoteDevice.connections.length,
-                            cpuPercent: 0.1,
-                            memPercent: 0.2,
-                            preferredDeviceIds: [...remoteDevice.preferredDeviceIds],
-                            timestampLastApplied: 0,
-                        };
-                    });
-                    const result = (0, device_election_1.electDevices)({
-                        deviceId: device.deviceId,
-                        myConnections: [...device.connections],
-                        allNetworkInfo: networkInfo,
-                    });
-                    device.preferredDeviceIds = result.preferredDeviceIds;
-                    device.preferredByDeviceIds = result.preferredByDeviceIds;
-                    // now that we've done elections, remove connections if we have too many (note this is slightly unrealistic as this usually happens before elections in the real code)
-                    while (device.connections.length >= MAX_CONNECTIONS) {
-                        const removeConn = (0, device_election_1.getLeastPreferredConnection)({
-                            connections: device.connections.map((c) => ({ ...c, groups: [groupId] })),
-                            preferredDeviceIds: [...device.preferredDeviceIds],
-                            preferredByDeviceIds: [...device.preferredByDeviceIds],
-                        });
-                        const disconnectDevice = deviceInfos.find((d) => d.deviceId === removeConn?.deviceId);
-                        disconnectDevices(device, disconnectDevice);
-                    }
-                }
-            }
-            const output = (0, lodash_1.sortBy)(deviceInfos, (d) => -d.preferredByDeviceIds.length).map((d) => {
-                return {
-                    preferredBy: d.preferredByDeviceIds.length,
-                    preferred: d.preferredDeviceIds.length,
-                    connCnt: d.connections.length,
-                    passiveCnt: d.connections.length - d.preferredDeviceIds.length,
-                };
-            });
-            // TODO - detect if every device is able to reach every other device or not
-            console.table(output);
-        });
-    });
-});

package/dist/device/device.test.d.ts

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