@pooflabs/core 0.0.28 → 0.0.29

package/dist/index.js

@@ -204,6 +204,11 @@ class WebSessionManager {
 }
 WebSessionManager.TAROBASE_SESSION_STORAGE_KEY = "tarobase_session_storage";
 
+var webSessionManager = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    WebSessionManager: WebSessionManager
+});
+
 function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 }
@@ -3101,11 +3106,19 @@ class ServerSessionManager {
 /* The single, shared instance */
 ServerSessionManager.instance = new ServerSessionManager();
 
+var serverSessionManager = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    ServerSessionManager: ServerSessionManager
+});
+
 async function createBearerToken(isServer) {
     if (isServer) {
         const sessionMgr = ServerSessionManager.instance;
         const session = await sessionMgr.getSession();
-        return `Bearer ${session === null || session === void 0 ? void 0 : session.idToken}`;
+        if (!(session === null || session === void 0 ? void 0 : session.idToken)) {
+            return null;
+        }
+        return `Bearer ${session.idToken}`;
     }
     const idToken = WebSessionManager.getIdToken();
     if (!idToken) {
@@ -3138,13 +3151,72 @@ async function getRefreshToken(isServer) {
     }
     return WebSessionManager.getRefreshToken();
 }
-function updateIdTokenAndAccessToken(idToken, accessToken) {
-    WebSessionManager.updateIdTokenAndAccessToken(idToken, accessToken);
+async function updateIdTokenAndAccessToken(idToken, accessToken, isServer = false) {
+    if (isServer) {
+        const sessionMgr = ServerSessionManager.instance;
+        // Ensure we have a session to update; if missing, let lazy creation happen on next request.
+        let session = null;
+        try {
+            session = await sessionMgr.getSession();
+        }
+        catch (_a) {
+            return;
+        }
+        if (!session) {
+            return;
+        }
+        sessionMgr.setSession(Object.assign(Object.assign({}, session), { idToken,
+            accessToken }));
+        return;
+    }
+    await WebSessionManager.updateIdTokenAndAccessToken(idToken, accessToken);
 }
 
+const refreshInFlight = new Map();
+async function refreshAuthSessionOnce(appId, isServer) {
+    const key = `${isServer ? "server" : "web"}:${appId}`;
+    const existing = refreshInFlight.get(key);
+    if (existing) {
+        return existing;
+    }
+    const refreshPromise = (async () => {
+        var _a, _b;
+        try {
+            const refreshToken = await getRefreshToken(isServer);
+            if (!refreshToken) {
+                return false;
+            }
+            const refreshData = await refreshSession(refreshToken);
+            if (!(refreshData === null || refreshData === void 0 ? void 0 : refreshData.idToken) || !(refreshData === null || refreshData === void 0 ? void 0 : refreshData.accessToken)) {
+                return false;
+            }
+            await updateIdTokenAndAccessToken(refreshData.idToken, refreshData.accessToken, isServer);
+            return true;
+        }
+        catch (error) {
+            if (!isServer && (((_a = error === null || error === void 0 ? void 0 : error.response) === null || _a === void 0 ? void 0 : _a.status) === 401 || ((_b = error === null || error === void 0 ? void 0 : error.response) === null || _b === void 0 ? void 0 : _b.status) === 403)) {
+                const { WebSessionManager } = await Promise.resolve().then(function () { return webSessionManager; });
+                WebSessionManager.clearSession();
+            }
+            return false;
+        }
+        finally {
+            refreshInFlight.delete(key);
+        }
+    })();
+    refreshInFlight.set(key, refreshPromise);
+    return refreshPromise;
+}
 async function makeApiRequest(method, urlPath, data, _overrides) {
     var _a, _b, _c, _d, _e, _f;
     const config = await getConfig();
+    let hasRetriedAfterServerSessionReset = false;
+    const clearServerSession = async () => {
+        if (!config.isServer)
+            return;
+        const { ServerSessionManager } = await Promise.resolve().then(function () { return serverSessionManager; });
+        ServerSessionManager.instance.clearSession();
+    };
     async function executeRequest() {
         const authHeader = await createAuthHeader(config.isServer);
         const headers = Object.assign({ "Content-Type": "application/json", "X-Public-App-Id": config.appId, "X-App-Id": config.appId }, authHeader);
@@ -3176,19 +3248,20 @@ async function makeApiRequest(method, urlPath, data, _overrides) {
     catch (error) {
         if (((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === 401) {
             try {
-                const refreshToken = await getRefreshToken(config.isServer);
-                if (!refreshToken) {
-                    throw new Error("No refresh token found");
-                }
-                const refreshData = await refreshSession(refreshToken);
-                if (refreshData &&
-                    refreshData.idToken &&
-                    refreshData.accessToken) {
-                    updateIdTokenAndAccessToken(refreshData.idToken, refreshData.accessToken);
+                const refreshed = await refreshAuthSessionOnce(config.appId, config.isServer);
+                if (!refreshed) {
+                    throw new Error("Unable to refresh auth session");
                 }
                 return await executeRequest();
             }
-            catch (refreshError) {
+            catch (_refreshError) {
+                // Server-side fallback: clear cached session and retry once to force
+                // createSession() with a fresh Cognito session.
+                if (config.isServer && !hasRetriedAfterServerSessionReset) {
+                    hasRetriedAfterServerSessionReset = true;
+                    await clearServerSession();
+                    return await executeRequest();
+                }
                 throw error;
             }
         }
@@ -3720,14 +3793,26 @@ const responseCache = new Map();
 const CACHE_TTL = 5 * 60 * 1000; // 5 minutes
 const TOKEN_REFRESH_BUFFER = 5 * 60 * 1000; // Refresh token 5 minutes before expiry
 // ============ WebSocket Config ============
+const BASE_MIN_RECONNECT_DELAY_MS = 1000;
+const MIN_RECONNECT_DELAY_JITTER_MS = 1000;
+const MAX_RECONNECT_DELAY_MS = 300000;
+const RECONNECT_DELAY_GROW_FACTOR = 1.8;
+const MIN_BROWSER_RECONNECT_INTERVAL_MS = 30000;
 const WS_CONFIG = {
-    maxRetries: 10,
-    minReconnectionDelay: 1000,
-    maxReconnectionDelay: 30000,
-    reconnectionDelayGrowFactor: 1.3,
-    connectionTimeout: 4000,
+    // Keep retrying indefinitely so long outages recover without page refresh.
+    maxRetries: Infinity,
+    // Conservative starting delay with jitter spreads reconnects across clients.
+    minReconnectionDelay: BASE_MIN_RECONNECT_DELAY_MS + Math.floor(Math.random() * MIN_RECONNECT_DELAY_JITTER_MS),
+    // Stretch backoff to 5 minutes during prolonged outages to protect backend pools.
+    maxReconnectionDelay: MAX_RECONNECT_DELAY_MS,
+    // Moderate growth to avoid rapid retry bursts while still converging to max delay.
+    reconnectionDelayGrowFactor: RECONNECT_DELAY_GROW_FACTOR,
+    // Give handshakes more time before considering the attempt failed.
+    connectionTimeout: 10000,
 };
 const WS_V2_PATH = '/ws/v2';
+let browserReconnectHooksAttached = false;
+let lastBrowserTriggeredReconnectAt = 0;
 // ============ Helper Functions ============
 function generateSubscriptionId() {
     return `sub_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
@@ -3797,7 +3882,7 @@ async function getFreshAuthToken(isServer) {
         }
         const refreshData = await refreshSession(refreshToken);
         if (refreshData && refreshData.idToken && refreshData.accessToken) {
-            updateIdTokenAndAccessToken(refreshData.idToken, refreshData.accessToken);
+            await updateIdTokenAndAccessToken(refreshData.idToken, refreshData.accessToken, isServer);
             return refreshData.idToken;
         }
     }
@@ -3806,8 +3891,54 @@ async function getFreshAuthToken(isServer) {
     }
     return currentToken;
 }
+function hasDisconnectedActiveConnections() {
+    for (const connection of connections.values()) {
+        if (!connection.ws) {
+            continue;
+        }
+        // Only nudge reconnection when socket is fully closed.
+        // If ReconnectingWebSocket is already in CONNECTING/backoff state, don't interfere.
+        if (connection.ws.readyState === WS_READY_STATE_CLOSED) {
+            return true;
+        }
+    }
+    return false;
+}
+function maybeReconnectFromBrowserSignal() {
+    const now = Date.now();
+    if (now - lastBrowserTriggeredReconnectAt < MIN_BROWSER_RECONNECT_INTERVAL_MS) {
+        return;
+    }
+    if (!hasDisconnectedActiveConnections()) {
+        return;
+    }
+    lastBrowserTriggeredReconnectAt = now;
+    reconnectWithNewAuthV2().catch((error) => {
+        console.error('[WS v2] Browser-triggered reconnect failed:', error);
+    });
+}
+function attachBrowserReconnectHooksOnce() {
+    if (browserReconnectHooksAttached) {
+        return;
+    }
+    if (typeof window === 'undefined') {
+        return;
+    }
+    browserReconnectHooksAttached = true;
+    window.addEventListener('online', () => {
+        maybeReconnectFromBrowserSignal();
+    });
+    if (typeof document !== 'undefined') {
+        document.addEventListener('visibilitychange', () => {
+            if (document.visibilityState === 'visible') {
+                maybeReconnectFromBrowserSignal();
+            }
+        });
+    }
+}
 // ============ Connection Management ============
 async function getOrCreateConnection(appId, isServer) {
+    attachBrowserReconnectHooksOnce();
     let connection = connections.get(appId);
     if (connection && connection.ws) {
         return connection;
@@ -3900,13 +4031,15 @@ function handleServerMessage(connection, message) {
         case 'subscribed': {
             const subscription = connection.subscriptions.get(message.subscriptionId);
             if (subscription) {
-                // Update cache
-                const cacheKey = getCacheKey(subscription.path, subscription.prompt, subscription.shape);
-                responseCache.set(cacheKey, { data: message.data, timestamp: Date.now() });
-                // Store last data
-                subscription.lastData = message.data;
-                // Notify callbacks
-                notifyCallbacks(subscription, message.data);
+                // A data update can race ahead of subscribed during reconnect.
+                // If we already received data for this subscription, treat subscribed
+                // as an ack only and avoid regressing to an older snapshot.
+                if (subscription.lastData === undefined) {
+                    const cacheKey = getCacheKey(subscription.path, subscription.prompt, subscription.shape);
+                    responseCache.set(cacheKey, { data: message.data, timestamp: Date.now() });
+                    subscription.lastData = message.data;
+                    notifyCallbacks(subscription, message.data);
+                }
             }
             // Resolve pending subscription promise
             const pending = connection.pendingSubscriptions.get(message.subscriptionId);
@@ -3972,6 +4105,7 @@ function notifyCallbacks(subscription, data) {
 }
 // WebSocket readyState constants
 const WS_READY_STATE_OPEN = 1;
+const WS_READY_STATE_CLOSED = 3;
 function sendSubscribe(connection, subscription) {
     if (!connection.ws || connection.ws.readyState !== WS_READY_STATE_OPEN) {
         return;