@persistica/flux-agent 0.0.24 → 0.0.26

package/index.js

@@ -40,6 +40,7 @@ var ON_NETWORK_CHANNEL_PUBLISH = "nc-on-pub";
 var SUBSCRIBE_NETWORK_CHANNEL_NAME = "subscribe-to-nc-name";
 var SUBSCRIBED_NETWORK_CHANNEL_NAME = "subscribed-to-nc-name";
 var UNSUBSCRIBE_NETWORK_CHANNEL_NAME = "unsubscribe-nc-name";
+var UNSUBSCRIBED_NETWORK_CHANNEL_NAME = "unsubscribed-nc-name";
 var AUTHORITY_CHANNEL_SUBSCRIBE = "acs";
 var AUTHORITY_DISCONNECT_AGENT = "ada";
 var ERROR = "e";
@@ -87,7 +88,7 @@ var validateNetworkIdOrThrow = (networkId) => {
 // libs/flux/shared/types/src/lib/client-id.type.ts
 var NANOID_LENGTH = 21;
 var NANOID_ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz-";
-var isNanoId = (id) => {
+var isClientId = (id) => {
   if (typeof id !== "string") {
     return false;
   }
@@ -198,7 +199,7 @@ var WebSocketClient = class extends RPCServer {
           );
           setTimeout(() => {
             this.reconnectAttempts++;
-            this.connect();
+            void this.connect();
           }, delay);
         } else if (this.options.autoReconnect) {
           this.emit("error", new Error("Connection failed: retries exhausted"));
@@ -402,9 +403,7 @@ var FluxAgentNetworkConnection = class {
         this._fluxWebSocketClientConnection,
         this._webRTCStateChange
       );
-      console.log(
-        this.iceConnection ? `RTCPeerConnection is available` : `RTCPeerConnection is not available`
-      );
+      console.log(`RTCPeerConnection is available`);
     } else {
       console.warn("\u2757WebRTC is not available in this environment.");
     }
@@ -422,7 +421,7 @@ var FluxAgentNetworkConnection = class {
     const fluxNetworkChannel = await this._fluxWebSocketConnection.joinChannel(
       channelName
     );
-    this.connectedChannelSet.add(fluxNetworkChannel.channelName);
+    this.connectedChannelSet.add(channelName);
     return fluxNetworkChannel;
   }
   /**
@@ -442,7 +441,7 @@ var FluxAgentNetworkConnection = class {
    * Connects to a remote agent.
    */
   connectToAgent(clientId) {
-    this._fluxWebSocketConnection.connectToAgent(clientId);
+    void this._fluxWebSocketConnection.connectToAgent(clientId);
     return new FluxRemoteClient(this.iceConnection);
   }
   /**
@@ -458,25 +457,25 @@ var hasOverlap = (a, b) => a && b ? [...a].some((item) => (Array.isArray(b) ? b
 var PicoLogger = /* @__PURE__ */ (() => {
   let allowScopes;
   const configure = (configuration) => {
-    allowScopes = typeof configuration.allowScopes === "string" && configuration.allowScopes === "*" ? "*" : new Set(configuration.allowScopes);
+    allowScopes = configuration.allowScopes === "*" ? "*" : new Set(configuration.allowScopes);
   };
   const log = (message, scopes) => {
     if (allowScopes !== "*" && !hasOverlap(allowScopes, scopes)) {
       return;
     }
-    console.log(`[${scopes}]	${message}`);
+    console.log(`[${scopes?.toString()}]	${message}`);
   };
   const warn = (message, scopes) => {
     if (allowScopes !== "*" && !hasOverlap(allowScopes, scopes)) {
       return;
     }
-    console.warn(`[${scopes}]	${message}`);
+    console.warn(`[${scopes?.toString()}]	${message}`);
   };
   const error = (message, scopes) => {
     if (allowScopes !== "*" && !hasOverlap(allowScopes, scopes)) {
       return;
     }
-    console.error(`[${scopes}]	${message}`);
+    console.error(`[${scopes?.toString()}]	${message}`);
   };
   return {
     configure,
@@ -488,8 +487,8 @@ var PicoLogger = /* @__PURE__ */ (() => {
 
 // libs/flux/shared/connection/src/lib/flux-network-channel.class.ts
 var FluxNetworkChannel = class {
-  constructor(channelName, _fluxWebSocketConnection) {
-    this.channelName = channelName;
+  constructor(_channelName, _fluxWebSocketConnection) {
+    this._channelName = _channelName;
     this._fluxWebSocketConnection = _fluxWebSocketConnection;
   }
   /**
@@ -497,7 +496,7 @@ var FluxNetworkChannel = class {
    */
   publish(message) {
     this._fluxWebSocketConnection.publish(
-      this.channelName,
+      this._channelName,
       message
     );
   }
@@ -506,7 +505,7 @@ var FluxNetworkChannel = class {
    */
   onPublish(fn) {
     this._fluxWebSocketConnection.onPublish(
-      this.channelName,
+      this._channelName,
       fn
       // TODO
     );
@@ -517,11 +516,17 @@ var FluxNetworkChannel = class {
 var CONNECTION_TIMEOUT_MS = 2e3;
 var ChannelStateManager = class {
   connectionTimeouts = /* @__PURE__ */ new Map();
+  joinedChannels = /* @__PURE__ */ new Map();
   /**
    * Join a channel.
    */
   async joinChannel(channelName, fluxWebSocketConnection, webSocketClient) {
     if (webSocketClient) {
+      const existingChannel = this.joinedChannels.get(channelName);
+      if (existingChannel) {
+        existingChannel.useCount++;
+        return Promise.resolve(existingChannel.channel);
+      }
       return new Promise((resolve, reject) => {
         const existingTimeout = this.connectionTimeouts.get(channelName);
         if (existingTimeout) {
@@ -539,7 +544,9 @@ var ChannelStateManager = class {
             this.connectionTimeouts.delete(channelName);
           }
           fluxWebSocketConnection.removePackageTypeInterceptor(SUBSCRIBED_NETWORK_CHANNEL_NAME, cb);
-          resolve(new FluxNetworkChannel(channelName, fluxWebSocketConnection));
+          const channel = new FluxNetworkChannel(channelName, fluxWebSocketConnection);
+          this.joinedChannels.set(channelName, { channel, useCount: 1 });
+          resolve(channel);
         };
         fluxWebSocketConnection.interceptPackageTypeMessages(
           SUBSCRIBED_NETWORK_CHANNEL_NAME,
@@ -561,9 +568,46 @@ var ChannelStateManager = class {
   /**
    * Leave a channel.
    */
-  async leaveChannel(channelName, webSocketClient) {
+  async leaveChannel(channelName, fluxWebSocketConnection, webSocketClient) {
+    const existingChannel = this.joinedChannels.get(channelName);
+    if (!existingChannel) {
+      return Promise.reject(new Error("No channel instance found"));
+    }
+    existingChannel.useCount--;
+    if (existingChannel.useCount <= 0) {
+      this.joinedChannels.delete(channelName);
+    }
+    if (webSocketClient && existingChannel.useCount <= 0) {
+      return new Promise((resolve, reject) => {
+        const cb = (message) => {
+          const receivedChannelName = message.substring(message.indexOf(":") + 1);
+          if (channelName !== receivedChannelName) {
+            return;
+          }
+          const timeout = this.connectionTimeouts.get(channelName);
+          if (timeout) {
+            clearTimeout(timeout);
+            this.connectionTimeouts.delete(channelName);
+          }
+          fluxWebSocketConnection.removePackageTypeInterceptor(UNSUBSCRIBED_NETWORK_CHANNEL_NAME, cb);
+          resolve(void 0);
+        };
+        fluxWebSocketConnection.interceptPackageTypeMessages(
+          UNSUBSCRIBED_NETWORK_CHANNEL_NAME,
+          cb
+        );
+        this.connectionTimeouts.set(
+          channelName,
+          setTimeout(() => {
+            this.connectionTimeouts.delete(channelName);
+            fluxWebSocketConnection.removePackageTypeInterceptor(UNSUBSCRIBED_NETWORK_CHANNEL_NAME, cb);
+            reject(new Error(`Channel unsubscription timed out for channel "${channelName}"`));
+          }, CONNECTION_TIMEOUT_MS)
+        );
+        webSocketClient.send(`${UNSUBSCRIBE_NETWORK_CHANNEL_NAME}:${channelName}`);
+      });
+    }
     if (webSocketClient) {
-      webSocketClient.send(`${UNSUBSCRIBE_NETWORK_CHANNEL_NAME}:${channelName}`);
       return Promise.resolve(void 0);
     }
     return Promise.reject(new Error("Not connected"));
@@ -579,8 +623,8 @@ var createWSConnection = (id, ticket, stateManager, onReconnectCallback, options
     ticket,
     {
       domain: options.domain,
-      secretKey: options?.secretKey,
-      retries: options?.retries
+      secretKey: options.secretKey,
+      retries: options.retries
     }
   );
 };
@@ -593,8 +637,8 @@ var FluxWebSocketConnection = class {
     this.options = options;
     this.options = {
       domain: this.options.domain,
-      secretKey: this.options?.secretKey,
-      retries: this.options?.retries ?? 1e4
+      secretKey: this.options.secretKey,
+      retries: this.options.retries ?? 1e4
     };
     const url = new URL(this.options.domain);
     url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
@@ -677,7 +721,6 @@ var FluxWebSocketConnection = class {
     });
     this.socket.clearEventSubscribers();
     this.socket.on("message", this.socketMessageHandler).on("close", this.socketCloseHandler).on("connecting", this.socketConnectingHandler).on("error", this.socketErrorHandler);
-    this.stateManager.emitNetworkState("connecting");
     void this.socket.connect();
     return this.connectPromise;
   }
@@ -731,6 +774,7 @@ var FluxWebSocketConnection = class {
   async leaveChannel(channelName) {
     return this.channelStateManager.leaveChannel(
       channelName,
+      this,
       this.webSocketClient
     );
   }
@@ -788,7 +832,7 @@ var FluxWebSocketConnection = class {
    * Disconnects an agent from the network.
    */
   disconnectAgent(id) {
-    if (!isNanoId(id)) {
+    if (!isClientId(id)) {
       throw new Error(`Invalid agent id: '${id}'`);
     }
     if (this.webSocketClient) {
@@ -817,9 +861,9 @@ var FluxWebSocketConnection = class {
     this.stateManager.emitNetworkState(reason === "kicked" ? "kicked" : "disconnected");
   }
   handleSocketConnecting(retryAttempt) {
-    this.stateManager.emitNetworkState("disconnected");
+    this.stateManager.emitNetworkState("connecting");
     if (retryAttempt > 0) {
-      PicoLogger.log(`\u{1F504} Connecting attempt: #${retryAttempt} of ${this.options?.retries ?? "none"}`, this.fluxInstanceId);
+      PicoLogger.log(`\u{1F504} Connecting attempt: #${retryAttempt} of ${this.options.retries ?? "none"}`, this.fluxInstanceId);
     } else {
       PicoLogger.log(`\u{1F504} Connecting: ${this.fluxInstanceId}`);
     }
@@ -865,26 +909,26 @@ var FluxWebSocketConnection = class {
             }
           }
         }
-        break;
+        return;
       }
       case RPC_REQUEST: {
         const payload = JSON.parse(message_.substring(message_.indexOf(":") + 1));
-        this.socket.handleMessage(payload, (data) => {
+        void this.socket.handleMessage(payload, (data) => {
           this.socket.send(`${RPC_RESPONSE}:${JSON.stringify(data)}`);
         });
-        break;
+        return;
       }
       case RPC_RESPONSE: {
         const payload = message_.substring(message_.indexOf(":") + 1);
         PicoLogger.log("\u{1F50C} Unhandled type rpc response", "ws-client");
         PicoLogger.log(`payload: ${payload}`, "ws-client");
-        break;
+        return;
       }
       default:
         if (message_.startsWith(`${ERROR}:`)) {
         }
         PicoLogger.log(`\u{1F50C} Unhandled type: "${message_}"`, "ws-client");
-        break;
+        return;
     }
   }
 };
@@ -1021,9 +1065,8 @@ var StateManager = class {
 
 // libs/flux/shared/utils/src/lib/promises.utils.ts
 var retryOrThrow = async (fn, shouldRetry, options) => {
-  let attempt = 0;
   let overrideDelay;
-  while (true) {
+  for (let attempt = 0; attempt <= options.retries; attempt++) {
     try {
       if (attempt > 0) {
         if (options.onRetry) {
@@ -1032,12 +1075,11 @@ var retryOrThrow = async (fn, shouldRetry, options) => {
       }
       return await fn();
     } catch (err) {
-      attempt++;
-      if (attempt > options.retries || !shouldRetry(err)) {
+      if (attempt >= options.retries || !shouldRetry(err)) {
         throw err;
       }
       if (options.delayMs > 0 || overrideDelay && overrideDelay > 0) {
-        let delay = overrideDelay ?? options.delayMs;
+        const delay = overrideDelay ?? options.delayMs;
         await new Promise((res) => setTimeout(
           res,
           delay
@@ -1045,6 +1087,7 @@ var retryOrThrow = async (fn, shouldRetry, options) => {
       }
     }
   }
+  throw new Error("Retry loop exited unexpectedly.");
 };
 
 // libs/flux/shared/utils/src/lib/machine-id.util.ts
@@ -1151,15 +1194,19 @@ var FluxClientData = class {
 // packages/flux/agent/src/lib/flux-agent.class.ts
 var DEFAULT_FLUX_DOMAIN = "https://mesh.persistica.io";
 var FluxAgent = class {
-  constructor(networkId, options) {
-    this.networkId = networkId;
-    this.options = options;
-    validateNetworkIdOrThrow(this.networkId);
-  }
   id = nanoid();
   fluxWebSocketConnection;
   fluxClientData = new FluxClientData();
   stateManager = new StateManager();
+  networkId;
+  options;
+  constructor(networkId, options) {
+    if (!validateNetworkIdOrThrow(networkId)) {
+      throw new Error("Will never be thrown");
+    }
+    this.networkId = networkId;
+    this.options = options;
+  }
   /**
    * Connect to the network using provided identification.
    * 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@persistica/flux-agent",
-    "version": "0.0.24",
+    "version": "0.0.26",
     "description": "Persistica Flux Agent",
     "type": "module",
     "keywords": [],

package/src/lib/flux-agent.class.d.ts

@@ -1,17 +1,17 @@
 import type { TMessageCallback } from '@flux/shared/ws';
 import type { FluxAgentNetworkConnection } from '@flux/shared/connection';
 export declare class FluxAgent {
-    private readonly networkId;
-    private readonly options?;
     readonly id: string;
     private fluxWebSocketConnection;
     private readonly fluxClientData;
     private readonly stateManager;
+    private readonly networkId;
+    private readonly options;
     constructor(networkId: string, options?: {
         domain?: string;
         secretKey?: string;
         retries?: number;
-    } | undefined);
+    });
     /**
      * Connect to the network using provided identification.
      *