@peers-app/peers-sdk 0.7.5 → 0.7.7

package/dist/context/user-context.d.ts

@@ -6,6 +6,7 @@ import { Observable } from "../observable";
 export declare class UserContext {
     readonly userId: string;
     readonly dataSourceFactory: DataSourceFactory;
+    readonly ephemeral?: boolean | undefined;
     readonly deviceId: Observable<string>;
     readonly currentlyActiveGroupId: Observable<string | undefined>;
     readonly reloadPackagesOnPageRefresh: Observable<boolean>;
@@ -14,7 +15,7 @@ export declare class UserContext {
     readonly groupDataContexts: Map<string, DataContext>;
     readonly defaultDataContext: Observable<DataContext>;
     readonly loadingPromise: Promise<UserContext>;
-    constructor(userId: string, dataSourceFactory: DataSourceFactory);
+    constructor(userId: string, dataSourceFactory: DataSourceFactory, ephemeral?: boolean | undefined);
     private init;
     /**
      * We want to load all packages as part of user context initialization

package/dist/context/user-context.js

@@ -11,6 +11,7 @@ const utils_1 = require("../utils");
 class UserContext {
     userId;
     dataSourceFactory;
+    ephemeral;
     deviceId = (0, observable_1.observable)('');
     currentlyActiveGroupId = (0, observable_1.observable)();
     reloadPackagesOnPageRefresh = (0, observable_1.observable)(false);
@@ -19,19 +20,20 @@ class UserContext {
     groupDataContexts = new Map();
     defaultDataContext;
     loadingPromise;
-    constructor(userId, dataSourceFactory) {
+    constructor(userId, dataSourceFactory, ephemeral) {
         this.userId = userId;
         this.dataSourceFactory = dataSourceFactory;
+        this.ephemeral = ephemeral;
+        if (ephemeral === undefined && typeof process !== 'undefined' && process.env.NODE_ENV === 'test') {
+            this.ephemeral = true;
+        }
         this.userDataContext = new data_context_1.DataContext(this);
         this.defaultDataContext = (0, observable_1.observable)(this.userDataContext);
         this.defaultDataContext(this.userDataContext);
         this.loadingPromise = this.init();
     }
     async init() {
-        if (typeof process !== 'undefined' && process.env.NODE_ENV === 'test') {
-            console.log(`not setting up user-context pvars during tests because they will interfere with other UserContext instances`);
-        }
-        else {
+        if (!this.ephemeral) {
             await this.loadUserContextObservablesFromDB();
         }
         await this.loadGroupContexts();

package/dist/data/data-locks.test.js

@@ -49,7 +49,10 @@ class MockPeerDevice {
             deviceId: this.deviceId,
             timestampLastApplied: Date.now(),
             connections: this.connections,
-            preferredDeviceIds: []
+            preferredDeviceIds: [],
+            cpuPercent: 10,
+            memPercent: 10,
+            connectionSlotsAvailable: 10,
         };
     }
     async listChanges(query) {

package/dist/device/connection.d.ts

@@ -32,10 +32,12 @@ export declare class Connection {
     exposeRPC<T extends Function>(fn: T): void;
     emit<T = any>(eventName: string, ...args: any): Promise<T>;
     on(eventName: string, handler: Function): void;
-    removeAllListeners(eventName: string): void;
+    removeAllListeners(eventName?: string): void;
     reset(): void;
     initiateHandshake(serverAddress: string, remoteDeviceInfo?: IDeviceInfo): IDataBox;
     completeHandshake(boxedHandshake: IDataBox): Promise<IDeviceHandshake>;
     doHandshake(remoteAddress: string): Promise<IDeviceHandshake>;
+    private closeLocal;
+    close(): Promise<void>;
 }
 export declare function normalizeAddress(address: string): string;

package/dist/device/connection.js

@@ -42,6 +42,11 @@ class Connection {
             socket.id = (0, utils_1.newid)();
         }
         // Only the server side of a connection should expose these methods
+        this.exposeRPC('close', () => {
+            (0, utils_1.sleep)(100).then(() => {
+                this.closeLocal();
+            });
+        });
         if (localDeviceServerAddresses) {
             this.exposeRPC('reset', this.reset.bind(this));
             this.exposeRPC('getTrustLevel', async (deviceInfo) => {
@@ -127,9 +132,9 @@ class Connection {
         });
     }
     on(eventName, handler) {
-        const handshakeEvents = ['requestDeviceInfo', 'completeHandshake', 'reset', 'getTrustLevel'];
+        const safeEvents = ['requestDeviceInfo', 'completeHandshake', 'reset', 'getTrustLevel', 'close'];
         this.socket.on(eventName, async (args, callback) => {
-            if (!this.verified && !handshakeEvents.includes(eventName)) {
+            if (!this.verified && !safeEvents.includes(eventName)) {
                 console.error(`Ignoring event from unverified connection: ${eventName}`);
                 return callback(`Connection not verified.  Handshake must be completed successfully before calling ${eventName}`);
             }
@@ -242,6 +247,18 @@ class Connection {
         console.log(`Connection ${this.connectionId} (${remoteAddress}) verified on client side with trust level ${this.trustLevel}`);
         return handshakeResponse;
     }
+    closeLocal() {
+        this.reset();
+        this.removeAllListeners();
+        this.socket.disconnect(true);
+    }
+    async close() {
+        await Promise.race([
+            this.emit('close'),
+            (0, utils_1.sleep)(100),
+        ]);
+        this.closeLocal();
+    }
 }
 exports.Connection = Connection;
 function normalizeAddress(address) {

package/dist/device/device-election.js

@@ -81,10 +81,12 @@ function sortConnections({ myDeviceId, connections, unconnectedDeviceIds }) {
     const MAX_CONNECTIONS = peer_device_1.PeerDeviceConsts.MAX_CONNECTIONS;
     // deprioritize devices that are close to max connections
     connections.sort((a, b) => {
-        const aConnCnt = a.preferredByDeviceIds.length + a.preferredDeviceIds.length;
-        const bConnCnt = b.preferredByDeviceIds.length + b.preferredDeviceIds.length;
-        const nearingMaxA = aConnCnt >= MAX_CONNECTIONS * 0.9;
-        const nearingMaxB = bConnCnt >= MAX_CONNECTIONS * 0.9;
+        // const aConnCnt = a.preferredByDeviceIds.length + a.preferredDeviceIds.length;
+        // const bConnCnt = b.preferredByDeviceIds.length + b.preferredDeviceIds.length;
+        // const nearingMaxA = aConnCnt >= MAX_CONNECTIONS * 0.9;
+        // const nearingMaxB = bConnCnt >= MAX_CONNECTIONS * 0.9;    
+        const nearingMaxA = a.connectionSlotsAvailable <= 3;
+        const nearingMaxB = b.connectionSlotsAvailable <= 3;
         if (nearingMaxA && !nearingMaxB)
             return 1;
         if (!nearingMaxA && nearingMaxB)

package/dist/device/socket.type.d.ts

@@ -5,8 +5,8 @@ export interface ISocket {
     connected?: boolean;
     emit(eventName: string, args: any, callback: RPCCallback): void;
     on(eventName: string, handler: ((...args: any[]) => void)): void;
-    removeAllListeners(eventName: string): void;
-    disconnect(): void;
+    removeAllListeners(eventName?: string): void;
+    disconnect(close?: boolean): void;
 }
 export declare enum TrustLevel {
     Malicious = -20,

package/dist/device/streamed-socket.d.ts

@@ -14,7 +14,7 @@ export declare class StreamedSocket implements ISocket {
     constructor(socket: ISocket, maxChunkSize?: number);
     get id(): string | undefined;
     get connected(): boolean | undefined;
-    disconnect(): void;
+    disconnect(close?: boolean): void;
     private readonly callbacks;
     emit(eventName: string, args: any, callback: RPCCallback): void;
     private handlers;

package/dist/device/streamed-socket.js

@@ -21,8 +21,8 @@ class StreamedSocket {
     get connected() {
         return this.socket.connected;
     }
-    disconnect() {
-        this.socket.disconnect();
+    disconnect(close) {
+        this.socket.disconnect(close);
     }
     callbacks = {};
     emit(eventName, args, callback) {

package/dist/types/peer-device.d.ts

@@ -17,12 +17,16 @@ export interface IDeviceMessage {
     ttl: number;
     payload: any;
     signature: string;
+    hops?: string[];
 }
 export interface INetworkInfo {
     deviceId: string;
     timestampLastApplied: number;
     connections: IDeviceConnection[];
     preferredDeviceIds: string[];
+    cpuPercent: number;
+    memPercent: number;
+    connectionSlotsAvailable: number;
 }
 export interface IDeviceConnection {
     deviceId: string;
@@ -30,6 +34,7 @@ export interface IDeviceConnection {
     errorRate: number;
     timestampLastApplied: number;
     onClose?(): Promise<void>;
+    closed?: boolean;
 }
 export declare const PeerDeviceConsts: Readonly<{
     MAX_CONNECTIONS: 30;

package/dist/utils.js

@@ -216,11 +216,17 @@ async function retryOnErrorOrTimeout({ fn, connection, opts = {}, }) {
             // timeout *= 2; // double the timeout for the next attempt
             timeoutCount++;
             finalError = undefined;
+            if (connection.closed) {
+                throw new Error(`connection has been closed`);
+            }
         }
         catch (error) {
             finalError = error;
             connection.errorRate = (connection.errorRate * 0.9) + 0.1;
             errorCount++;
+            if (connection.closed) {
+                throw new Error(`connection has been closed`);
+            }
         }
         console.warn(`Call failed, retrying: timeout is ${timeout}ms, errorCount: ${errorCount} of ${retriesOnError}, timeoutCount: ${timeoutCount} of ${retriesOnTimeout + 1}. Last error:`, finalError);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peers-app/peers-sdk",
-  "version": "0.7.5",
+  "version": "0.7.7",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/peers-app/peers-sdk.git"