@pooflabs/core 0.0.28 → 0.0.30

package/dist/client/operations.d.ts

@@ -22,6 +22,11 @@ export type GetOptions = {
         headers?: Record<string, string>;
     };
 };
+export type RunQueryOptions = {
+    _overrides?: {
+        headers?: Record<string, string>;
+    };
+};
 export declare function get(path: string, opts?: GetOptions): Promise<any>;
 export type RunExpressionOptions = {
     returnType?: 'Bool' | 'String' | 'Int' | 'UInt';
@@ -38,12 +43,12 @@ export type RunExpressionResult = {
         result?: any;
     }[];
 };
-export declare function runQuery(absolutePath: string, queryName: string, queryArgs: any): Promise<any>;
+export declare function runQuery(absolutePath: string, queryName: string, queryArgs: any, opts?: RunQueryOptions): Promise<any>;
 export declare function runQueryMany(many: {
     absolutePath: string;
     queryName: string;
     queryArgs: any;
-}[]): Promise<any>;
+}[], opts?: RunQueryOptions): Promise<any>;
 export declare function runExpression(expression: string, queryArgs: any, options?: RunExpressionOptions): Promise<RunExpressionResult>;
 export declare function runExpressionMany(many: {
     expression: string;

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;
+    var _a, _b, _c, _d;
     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,27 +3248,34 @@ 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;
             }
         }
         if (((_b = error.response) === null || _b === void 0 ? void 0 : _b.status) == 404) {
             return { data: null, status: 404 };
         }
-        if ((_d = (_c = error.response) === null || _c === void 0 ? void 0 : _c.data) === null || _d === void 0 ? void 0 : _d.message) {
-            throw new Error((_f = (_e = error.response) === null || _e === void 0 ? void 0 : _e.data) === null || _f === void 0 ? void 0 : _f.message);
+        if ((_c = error.response) === null || _c === void 0 ? void 0 : _c.data) {
+            const responseData = typeof error.response.data === 'object'
+                ? error.response.data
+                : { message: String(error.response.data) };
+            const apiError = new Error(responseData.message || error.message || 'Request failed');
+            Object.assign(apiError, responseData);
+            apiError.statusCode = (_d = error.response) === null || _d === void 0 ? void 0 : _d.status;
+            throw apiError;
         }
         throw error;
     }
@@ -3261,6 +3340,40 @@ async function getConfig() {
     return clientConfig;
 }
 
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
 // Cache for get responses
 const getCache = {};
 // Track in-flight requests to coalesce multiple identical requests
@@ -3358,11 +3471,11 @@ function cleanupExpiredCache() {
     });
     lastCacheCleanup = now;
 }
-async function runQuery(absolutePath, queryName, queryArgs) {
-    const result = await runQueryMany([{ absolutePath, queryName, queryArgs }]);
+async function runQuery(absolutePath, queryName, queryArgs, opts) {
+    const result = await runQueryMany([{ absolutePath, queryName, queryArgs }], opts);
     return result[0];
 }
-async function runQueryMany(many) {
+async function runQueryMany(many, opts) {
     try {
         let queries = [];
         for (const { absolutePath, queryName, queryArgs } of many) {
@@ -3373,7 +3486,7 @@ async function runQueryMany(many) {
             }
             queries.push({ path: normalizedPath, queryName, queryArgs });
         }
-        const response = await makeApiRequest('POST', 'queries', { queries }, undefined);
+        const response = await makeApiRequest('POST', 'queries', { queries }, opts === null || opts === void 0 ? void 0 : opts._overrides);
         return response.data.queries.map((result) => result.result);
     }
     catch (error) {
@@ -3490,6 +3603,12 @@ async function setMany(many, options) {
             if (setResponse.data === true) {
                 return Object.assign(Object.assign({}, documents.map(d => d.document)), { transactionId: null });
             }
+            else if (setResponse.data &&
+                typeof setResponse.data === 'object' &&
+                setResponse.data.success === true) {
+                const _a = setResponse.data, { success: _success } = _a, rest = __rest(_a, ["success"]);
+                return Object.assign(Object.assign(Object.assign({}, documents.map(d => d.document)), rest), { transactionId: null });
+            }
             else {
                 return Object.assign(Object.assign({}, setResponse.data), { transactionId: null });
             }
@@ -3720,14 +3839,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 +3928,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 +3937,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 +4077,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 +4151,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;