@pooflabs/core 0.0.27 → 0.0.29

package/dist/client/operations.d.ts

@@ -5,13 +5,24 @@ export type SetOptions = {
         headers?: Record<string, string>;
     };
 };
-export declare function get(path: string, opts?: {
+/**
+ * Options for the get function.
+ */
+export type GetOptions = {
+    /** Natural language prompt for AI-powered queries (collections only) */
     prompt?: string | undefined;
+    /** Bypass the local cache and fetch fresh data */
     bypassCache?: boolean;
+    /** Include documents from sub-paths (nested collections) */
+    includeSubPaths?: boolean;
+    /** Shape object for relationship resolution - specifies which related documents to include */
+    shape?: Record<string, any>;
+    /** Internal overrides for headers */
     _overrides?: {
         headers?: Record<string, string>;
     };
-}): Promise<any>;
+};
+export declare function get(path: string, opts?: GetOptions): Promise<any>;
 export type RunExpressionOptions = {
     returnType?: 'Bool' | 'String' | 'Int' | 'UInt';
     _overrides?: {

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 export { init } from './client/config';
 export { getConfig, ClientConfig } from './client/config';
-export { get, set, setMany, setFile, getFiles, runQuery, runQueryMany, runExpression, runExpressionMany, signMessage, signTransaction, signAndSubmitTransaction, SetOptions, RunExpressionOptions, RunExpressionResult } from './client/operations';
+export { get, set, setMany, setFile, getFiles, runQuery, runQueryMany, runExpression, runExpressionMany, signMessage, signTransaction, signAndSubmitTransaction, SetOptions, GetOptions, RunExpressionOptions, RunExpressionResult } from './client/operations';
 export { subscribe, closeAllSubscriptions, clearCache, getCachedData, reconnectWithNewAuth } from './client/subscription';
 export * from './types';
 export { getIdToken } from './utils/utils';

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;
             }
         }
@@ -3279,8 +3352,10 @@ async function get(path, opts = {}) {
         if (!normalizedPath || normalizedPath.length === 0) {
             return new Error("Invalid path provided.");
         }
-        // Create cache key combining path and prompt
-        const cacheKey = `${normalizedPath}:${opts.prompt || ''}`;
+        // Create cache key combining path, prompt, includeSubPaths, and shape
+        const shapeKey = opts.shape ? JSON.stringify(opts.shape) : '';
+        const includeSubPathsKey = opts.includeSubPaths ? ':subpaths' : '';
+        const cacheKey = `${normalizedPath}:${opts.prompt || ''}${includeSubPathsKey}:${shapeKey}`;
         const now = Date.now();
         // Check for valid cache entry if not bypassing cache
         if (!opts.bypassCache && getCache[cacheKey] && now < getCache[cacheKey].expiresAt) {
@@ -3301,15 +3376,20 @@ async function get(path, opts = {}) {
                 // Cache miss or bypass - proceed with API request
                 const pathIsDocument = normalizedPath.split("/").length % 2 === 0;
                 let response;
+                // Build common query params
+                const includeSubPathsParam = opts.includeSubPaths ? '&includeSubPaths=true' : '';
+                const shapeParam = opts.shape ? `&shape=${encodeURIComponent(JSON.stringify(opts.shape))}` : '';
                 if (pathIsDocument) {
                     const itemId = encodeURIComponent(normalizedPath);
-                    const apiPath = `items/${itemId}`;
+                    // For documents, query params go after the path
+                    const queryParams = [includeSubPathsParam, shapeParam].filter(p => p).join('');
+                    const apiPath = queryParams ? `items/${itemId}?${queryParams.substring(1)}` : `items/${itemId}`;
                     response = await makeApiRequest('GET', apiPath, null, opts._overrides);
                 }
                 else {
                     const path = encodeURIComponent(normalizedPath);
                     const promptQueryParam = (opts === null || opts === void 0 ? void 0 : opts.prompt) ? `&prompt=${btoa(opts.prompt)}` : "";
-                    const apiPath = `items?path=${path}${promptQueryParam}`;
+                    const apiPath = `items?path=${path}${promptQueryParam}${includeSubPathsParam}${shapeParam}`;
                     response = await makeApiRequest('GET', apiPath, null, opts._overrides);
                 }
                 // Cache the response (unless bypassing cache)
@@ -3713,21 +3793,34 @@ 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)}`;
 }
-function getCacheKey(path, prompt) {
+function getCacheKey(path, prompt, shape) {
     const normalizedPath = path.startsWith('/') ? path.slice(1) : path;
-    return `${normalizedPath}:${prompt || 'default'}`;
+    const shapeKey = shape && Object.keys(shape).length > 0 ? JSON.stringify(shape) : '';
+    return `${normalizedPath}:${prompt || 'default'}:${shapeKey}`;
 }
 function isTokenExpired(token) {
     try {
@@ -3789,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;
         }
     }
@@ -3798,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;
@@ -3892,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);
-                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);
@@ -3921,7 +4062,7 @@ function handleServerMessage(connection, message) {
             const subscription = connection.subscriptions.get(message.subscriptionId);
             if (subscription) {
                 // Update cache
-                const cacheKey = getCacheKey(subscription.path, subscription.prompt);
+                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;
@@ -3964,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;
@@ -3974,6 +4116,9 @@ function sendSubscribe(connection, subscription) {
         path: subscription.path,
         prompt: subscription.prompt ? btoa(subscription.prompt) : undefined,
         includeSubPaths: subscription.includeSubPaths,
+        shape: subscription.shape && Object.keys(subscription.shape).length > 0
+            ? subscription.shape
+            : undefined,
     };
     try {
         connection.ws.send(JSON.stringify(message));
@@ -4005,7 +4150,7 @@ function sendUnsubscribe(connection, subscriptionId) {
 async function subscribeV2(path, subscriptionOptions) {
     const config = await getConfig();
     const normalizedPath = path.startsWith('/') ? path.slice(1) : path;
-    const cacheKey = getCacheKey(normalizedPath, subscriptionOptions.prompt);
+    const cacheKey = getCacheKey(normalizedPath, subscriptionOptions.prompt, subscriptionOptions.shape);
     // Deliver cached data immediately if available
     const cachedEntry = responseCache.get(cacheKey);
     if (cachedEntry && Date.now() - cachedEntry.timestamp < CACHE_TTL && subscriptionOptions.onData) {
@@ -4016,10 +4161,12 @@ async function subscribeV2(path, subscriptionOptions) {
     }
     // Get or create connection for this appId
     const connection = await getOrCreateConnection(config.appId, config.isServer);
-    // Check if we already have a subscription for this path+prompt
+    // Check if we already have a subscription for this path+prompt+shape
+    const shapeKey = subscriptionOptions.shape ? JSON.stringify(subscriptionOptions.shape) : '';
     let existingSubscription;
     for (const sub of connection.subscriptions.values()) {
-        if (sub.path === normalizedPath && sub.prompt === subscriptionOptions.prompt) {
+        const subShapeKey = sub.shape ? JSON.stringify(sub.shape) : '';
+        if (sub.path === normalizedPath && sub.prompt === subscriptionOptions.prompt && subShapeKey === shapeKey) {
             existingSubscription = sub;
             break;
         }
@@ -4044,6 +4191,7 @@ async function subscribeV2(path, subscriptionOptions) {
         subscriptionId,
         path: normalizedPath,
         prompt: subscriptionOptions.prompt,
+        shape: subscriptionOptions.shape,
         includeSubPaths: false,
         callbacks: [subscriptionOptions],
         lastData: undefined,