spacetimedb 2.5.0 → 2.6.0

package/dist/tanstack/index.mjs

@@ -1711,6 +1711,14 @@ function useSpacetimeDB() {
 }
 
 // src/sdk/connection_manager.ts
+var CONNECTION_MANAGER_RECONNECT_BASE_DELAY_MS = 1e3;
+var CONNECTION_MANAGER_RECONNECT_MAX_DELAY_MS = 3e4;
+function connectionManagerReconnectDelayMs(attempt) {
+  return Math.min(
+    CONNECTION_MANAGER_RECONNECT_BASE_DELAY_MS * 2 ** attempt,
+    CONNECTION_MANAGER_RECONNECT_MAX_DELAY_MS
+  );
+}
 function defaultState() {
   return {
     isActive: false,
@@ -1737,10 +1745,13 @@ var ConnectionManagerImpl = class _ConnectionManagerImpl {
     }
     const managed = {
       connection: void 0,
+      builder: void 0,
       refCount: 0,
       state: defaultState(),
       listeners: /* @__PURE__ */ new Set(),
-      pendingRelease: null
+      pendingRelease: null,
+      reconnectTimer: null,
+      reconnectAttempt: 0
     };
     this.#connections.set(key, managed);
     return managed;
@@ -1750,40 +1761,20 @@ var ConnectionManagerImpl = class _ConnectionManagerImpl {
       listener();
     }
   }
-  /**
-   * Retains a connection, incrementing its reference count.
-   * Creates the connection on first call; returns existing connection on subsequent calls.
-   * Cancels any pending release if the connection was about to be cleaned up.
-   *
-   * @param key - Unique identifier for the connection (use getKey to generate)
-   * @param builder - Connection builder to create the connection if needed
-   * @returns The managed connection instance
-   */
-  retain(key, builder) {
-    const managed = this.#ensureEntry(key);
-    if (managed.pendingRelease) {
-      clearTimeout(managed.pendingRelease);
-      managed.pendingRelease = null;
-    }
-    managed.refCount += 1;
-    if (managed.connection) {
-      return managed.connection;
+  #updateState(managed, updates) {
+    managed.state = { ...managed.state, ...updates };
+    this.#notify(managed);
+  }
+  #ensureCallbacks(managed) {
+    if (managed.onConnect) {
+      return;
     }
-    const connection = builder.build();
-    managed.connection = connection;
-    const updateState = (updates) => {
-      managed.state = { ...managed.state, ...updates };
-      this.#notify(managed);
-    };
-    updateState({
-      isActive: connection.isActive,
-      identity: connection.identity,
-      token: connection.token,
-      connectionId: connection.connectionId,
-      connectionError: void 0
-    });
     managed.onConnect = (conn) => {
-      updateState({
+      if (conn !== managed.connection) {
+        return;
+      }
+      managed.reconnectAttempt = 0;
+      this.#updateState(managed, {
         isActive: conn.isActive,
         identity: conn.identity,
         token: conn.token,
@@ -1792,22 +1783,105 @@ var ConnectionManagerImpl = class _ConnectionManagerImpl {
       });
     };
     managed.onDisconnect = (ctx, error) => {
-      updateState({
-        isActive: ctx.isActive,
+      if (ctx !== managed.connection) {
+        return;
+      }
+      this.#updateState(managed, {
+        isActive: false,
         connectionError: error ?? void 0
       });
+      this.#scheduleReconnect(managed);
     };
     managed.onConnectError = (ctx, error) => {
-      updateState({
-        isActive: ctx.isActive,
+      if (ctx !== managed.connection) {
+        return;
+      }
+      this.#updateState(managed, {
+        isActive: false,
         connectionError: error
       });
+      this.#scheduleReconnect(managed);
     };
+  }
+  #attachCallbacks(managed, builder) {
+    this.#ensureCallbacks(managed);
     builder.onConnect(managed.onConnect);
     builder.onDisconnect(managed.onDisconnect);
     builder.onConnectError(managed.onConnectError);
+  }
+  #detachCallbacks(managed, connection) {
+    if (managed.onConnect) {
+      connection.removeOnConnect(managed.onConnect);
+    }
+    if (managed.onDisconnect) {
+      connection.removeOnDisconnect(managed.onDisconnect);
+    }
+    if (managed.onConnectError) {
+      connection.removeOnConnectError(managed.onConnectError);
+    }
+  }
+  #buildManagedConnection(managed, builder) {
+    managed.builder = builder;
+    const connection = builder.build();
+    managed.connection = connection;
+    this.#attachCallbacks(managed, builder);
+    this.#updateState(managed, {
+      isActive: connection.isActive,
+      identity: connection.identity,
+      token: connection.token,
+      connectionId: connection.connectionId,
+      connectionError: void 0
+    });
     return connection;
   }
+  #scheduleReconnect(managed) {
+    if (managed.refCount <= 0 || managed.pendingRelease || managed.reconnectTimer || !managed.builder) {
+      return;
+    }
+    const connection = managed.connection;
+    if (connection) {
+      this.#detachCallbacks(managed, connection);
+    }
+    managed.connection = void 0;
+    if (connection?.isDisconnectRequested) {
+      return;
+    }
+    const delay = connectionManagerReconnectDelayMs(managed.reconnectAttempt);
+    managed.reconnectAttempt += 1;
+    managed.reconnectTimer = setTimeout(() => {
+      managed.reconnectTimer = null;
+      if (managed.refCount <= 0 || managed.pendingRelease || managed.connection || !managed.builder) {
+        return;
+      }
+      this.#buildManagedConnection(managed, managed.builder);
+    }, delay);
+  }
+  /**
+   * Retains a connection, incrementing its reference count.
+   * Creates the connection on first call; returns existing connection on subsequent calls.
+   * Cancels any pending release if the connection was about to be cleaned up.
+   *
+   * @param key - Unique identifier for the connection (use getKey to generate)
+   * @param builder - Connection builder to create the connection if needed
+   * @returns The managed connection instance
+   */
+  retain(key, builder) {
+    const managed = this.#ensureEntry(key);
+    if (managed.pendingRelease) {
+      clearTimeout(managed.pendingRelease);
+      managed.pendingRelease = null;
+    }
+    if (managed.reconnectTimer) {
+      clearTimeout(managed.reconnectTimer);
+      managed.reconnectTimer = null;
+    }
+    managed.refCount += 1;
+    managed.builder = builder;
+    if (managed.connection) {
+      return managed.connection;
+    }
+    return this.#buildManagedConnection(managed, builder);
+  }
   release(key) {
     const managed = this.#connections.get(key);
     if (!managed) {
@@ -1817,24 +1891,20 @@ var ConnectionManagerImpl = class _ConnectionManagerImpl {
     if (managed.refCount > 0 || managed.pendingRelease) {
       return;
     }
+    if (managed.reconnectTimer) {
+      clearTimeout(managed.reconnectTimer);
+      managed.reconnectTimer = null;
+    }
     managed.pendingRelease = setTimeout(() => {
       managed.pendingRelease = null;
       if (managed.refCount > 0) {
         return;
       }
-      if (managed.connection) {
-        if (managed.onConnect) {
-          managed.connection.removeOnConnect(managed.onConnect);
-        }
-        if (managed.onDisconnect) {
-          managed.connection.removeOnDisconnect(managed.onDisconnect);
-        }
-        if (managed.onConnectError) {
-          managed.connection.removeOnConnectError(
-            managed.onConnectError
-          );
-        }
-        managed.connection.disconnect();
+      const connection = managed.connection;
+      managed.connection = void 0;
+      if (connection) {
+        this.#detachCallbacks(managed, connection);
+        connection.disconnect();
       }
       this.#connections.delete(key);
     }, 0);