@peers-app/peers-sdk 0.7.6 → 0.7.7

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/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

@@ -34,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.6",
+  "version": "0.7.7",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/peers-app/peers-sdk.git"