@trainly/react 1.1.0 → 1.1.3

package/dist/TrainlyProvider.d.ts

@@ -8,7 +8,8 @@ export interface TrainlyProviderProps {
     baseUrl?: string;
     userId?: string;
     userEmail?: string;
+    getToken?: () => Promise<string | null>;
 }
 export declare function TrainlyProvider({ children, appSecret, apiKey, appId, // NEW: For V1 authentication
-baseUrl, userId, userEmail, }: TrainlyProviderProps): import("react/jsx-runtime").JSX.Element;
+baseUrl, userId, userEmail, getToken, }: TrainlyProviderProps): import("react/jsx-runtime").JSX.Element;
 export declare function useTrainlyContext(): TrainlyContextValue;

package/dist/TrainlyProvider.js

@@ -52,7 +52,7 @@ export function TrainlyProvider(_a) {
     var _this = this;
     var children = _a.children, appSecret = _a.appSecret, apiKey = _a.apiKey, appId = _a.appId, // NEW: For V1 authentication
     _b = _a.baseUrl, // NEW: For V1 authentication
-    baseUrl = _b === void 0 ? "http://localhost:8000" : _b, userId = _a.userId, userEmail = _a.userEmail;
+    baseUrl = _b === void 0 ? "http://localhost:8000" : _b, userId = _a.userId, userEmail = _a.userEmail, getToken = _a.getToken;
     var client = React.useState(function () {
         return new TrainlyClient({
             appSecret: appSecret,
@@ -67,9 +67,67 @@ export function TrainlyProvider(_a) {
     var _d = React.useState(false), isConnected = _d[0], setIsConnected = _d[1];
     var _e = React.useState(null), error = _e[0], setError = _e[1];
     var _f = React.useState([]), messages = _f[0], setMessages = _f[1];
-    // Auto-connect on mount
+    var _g = React.useState(null), currentToken = _g[0], setCurrentToken = _g[1];
+    var refreshIntervalRef = React.useRef(null);
+    // Auto-connect on mount (only for non-OAuth modes)
     React.useEffect(function () {
-        connect();
+        if (!appId && !getToken) {
+            connect();
+        }
+    }, []);
+    // NEW: Automatic OAuth state management
+    React.useEffect(function () {
+        if (!getToken || !appId)
+            return;
+        var manageOAuthConnection = function () { return __awaiter(_this, void 0, void 0, function () {
+            var token, error_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 6, , 7]);
+                        return [4 /*yield*/, getToken()];
+                    case 1:
+                        token = _a.sent();
+                        if (!(token && token !== currentToken)) return [3 /*break*/, 4];
+                        if (!(!isConnected || token !== currentToken)) return [3 /*break*/, 3];
+                        console.log("🔐 New OAuth session detected, connecting to Trainly...");
+                        return [4 /*yield*/, connectWithOAuthToken(token)];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3: return [3 /*break*/, 5];
+                    case 4:
+                        if (!token && isConnected) {
+                            // User signed out, disconnect from Trainly
+                            console.log("🚪 User signed out, disconnecting from Trainly...");
+                            clearRefreshInterval();
+                            setIsConnected(false);
+                            setCurrentToken(null);
+                            setError(null);
+                        }
+                        _a.label = 5;
+                    case 5: return [3 /*break*/, 7];
+                    case 6:
+                        error_1 = _a.sent();
+                        console.error("OAuth state management error:", error_1);
+                        return [3 /*break*/, 7];
+                    case 7: return [2 /*return*/];
+                }
+            });
+        }); };
+        // Check OAuth state immediately
+        manageOAuthConnection();
+        // Set up periodic OAuth state checking (every 10 seconds)
+        var stateCheckInterval = setInterval(manageOAuthConnection, 10000);
+        return function () {
+            clearInterval(stateCheckInterval);
+        };
+    }, [getToken, appId, currentToken, isConnected]);
+    // Cleanup on unmount
+    React.useEffect(function () {
+        return function () {
+            clearRefreshInterval();
+        };
     }, []);
     var connect = function () { return __awaiter(_this, void 0, void 0, function () {
         var err_1;
@@ -100,7 +158,62 @@ export function TrainlyProvider(_a) {
             }
         });
     }); };
-    // NEW: V1 OAuth Token connection method
+    // Clear any existing refresh interval
+    var clearRefreshInterval = function () {
+        if (refreshIntervalRef.current) {
+            clearInterval(refreshIntervalRef.current);
+            refreshIntervalRef.current = null;
+        }
+    };
+    // Set up automatic token refresh
+    var setupTokenRefresh = function (token) {
+        if (!getToken || !appId)
+            return;
+        // Clear any existing interval
+        clearRefreshInterval();
+        // Decode token to get expiration (without verification)
+        try {
+            var payload = JSON.parse(atob(token.split(".")[1]));
+            var exp = payload.exp * 1000; // Convert to milliseconds
+            var now = Date.now();
+            var timeUntilExpiry = exp - now;
+            // Refresh 30 seconds before expiry (or immediately if already expired)
+            var refreshIn = Math.max(timeUntilExpiry - 30000, 1000);
+            console.log("\uD83D\uDD04 Token refresh scheduled in ".concat(Math.round(refreshIn / 1000), " seconds"));
+            refreshIntervalRef.current = setTimeout(function () { return __awaiter(_this, void 0, void 0, function () {
+                var newToken, error_2;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            _a.trys.push([0, 4, , 5]);
+                            console.log("🔄 Auto-refreshing token...");
+                            return [4 /*yield*/, getToken()];
+                        case 1:
+                            newToken = _a.sent();
+                            if (!(newToken && newToken !== currentToken)) return [3 /*break*/, 3];
+                            return [4 /*yield*/, client.connectWithOAuthToken(newToken)];
+                        case 2:
+                            _a.sent();
+                            setCurrentToken(newToken);
+                            setupTokenRefresh(newToken); // Schedule next refresh
+                            console.log("✅ Token auto-refreshed successfully");
+                            _a.label = 3;
+                        case 3: return [3 /*break*/, 5];
+                        case 4:
+                            error_2 = _a.sent();
+                            console.error("❌ Auto token refresh failed:", error_2);
+                            setIsConnected(false);
+                            return [3 /*break*/, 5];
+                        case 5: return [2 /*return*/];
+                    }
+                });
+            }); }, refreshIn);
+        }
+        catch (error) {
+            console.warn("Could not decode token for refresh scheduling:", error);
+        }
+    };
+    // NEW: V1 OAuth Token connection method with auto-refresh
     var connectWithOAuthToken = function (idToken) { return __awaiter(_this, void 0, void 0, function () {
         var err_2;
         return __generator(this, function (_a) {
@@ -112,7 +225,10 @@ export function TrainlyProvider(_a) {
                     return [4 /*yield*/, client.connectWithOAuthToken(idToken)];
                 case 1:
                     _a.sent();
+                    setCurrentToken(idToken);
                     setIsConnected(true);
+                    // Set up automatic token refresh
+                    setupTokenRefresh(idToken);
                     return [3 /*break*/, 4];
                 case 2:
                     err_2 = _a.sent();
@@ -131,11 +247,11 @@ export function TrainlyProvider(_a) {
         });
     }); };
     var ask = function (question) { return __awaiter(_this, void 0, void 0, function () {
-        var response, err_3, error_1;
+        var response, err_3, errorMessage, newToken, response, refreshError_1, error_3;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
-                    _a.trys.push([0, 2, 3, 4]);
+                    _a.trys.push([0, 2, 10, 11]);
                     setIsLoading(true);
                     setError(null);
                     return [4 /*yield*/, client.ask(question)];
@@ -144,22 +260,50 @@ export function TrainlyProvider(_a) {
                     return [2 /*return*/, response.answer];
                 case 2:
                     err_3 = _a.sent();
-                    error_1 = {
+                    errorMessage = err_3 instanceof Error ? err_3.message : String(err_3);
+                    if (!(getToken &&
+                        appId &&
+                        (errorMessage.includes("401") ||
+                            errorMessage.includes("authentication") ||
+                            errorMessage.includes("Unauthorized")))) return [3 /*break*/, 9];
+                    _a.label = 3;
+                case 3:
+                    _a.trys.push([3, 8, , 9]);
+                    console.log("🔄 Token expired, refreshing...");
+                    return [4 /*yield*/, getToken()];
+                case 4:
+                    newToken = _a.sent();
+                    if (!newToken) return [3 /*break*/, 7];
+                    return [4 /*yield*/, client.connectWithOAuthToken(newToken)];
+                case 5:
+                    _a.sent();
+                    return [4 /*yield*/, client.ask(question)];
+                case 6:
+                    response = _a.sent();
+                    console.log("✅ Query succeeded after token refresh");
+                    return [2 /*return*/, response.answer];
+                case 7: return [3 /*break*/, 9];
+                case 8:
+                    refreshError_1 = _a.sent();
+                    console.error("❌ Token refresh failed:", refreshError_1);
+                    return [3 /*break*/, 9];
+                case 9:
+                    error_3 = {
                         code: "QUERY_FAILED",
                         message: "Failed to get answer",
                         details: err_3,
                     };
-                    setError(error_1);
-                    throw error_1;
-                case 3:
+                    setError(error_3);
+                    throw error_3;
+                case 10:
                     setIsLoading(false);
                     return [7 /*endfinally*/];
-                case 4: return [2 /*return*/];
+                case 11: return [2 /*return*/];
             }
         });
     }); };
     var askWithCitations = function (question) { return __awaiter(_this, void 0, void 0, function () {
-        var response, err_4, error_2;
+        var response, err_4, error_4;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
@@ -175,13 +319,13 @@ export function TrainlyProvider(_a) {
                         }];
                 case 2:
                     err_4 = _a.sent();
-                    error_2 = {
+                    error_4 = {
                         code: "QUERY_FAILED",
                         message: "Failed to get answer with citations",
                         details: err_4,
                     };
-                    setError(error_2);
-                    throw error_2;
+                    setError(error_4);
+                    throw error_4;
                 case 3:
                     setIsLoading(false);
                     return [7 /*endfinally*/];
@@ -190,11 +334,11 @@ export function TrainlyProvider(_a) {
         });
     }); };
     var upload = function (file) { return __awaiter(_this, void 0, void 0, function () {
-        var result, err_5, error_3;
+        var result, err_5, errorMessage, newToken, result, refreshError_2, error_5;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
-                    _a.trys.push([0, 2, 3, 4]);
+                    _a.trys.push([0, 2, 10, 11]);
                     setIsLoading(true);
                     setError(null);
                     return [4 /*yield*/, client.upload(file)];
@@ -203,17 +347,45 @@ export function TrainlyProvider(_a) {
                     return [2 /*return*/, result];
                 case 2:
                     err_5 = _a.sent();
-                    error_3 = {
+                    errorMessage = err_5 instanceof Error ? err_5.message : String(err_5);
+                    if (!(getToken &&
+                        appId &&
+                        (errorMessage.includes("401") ||
+                            errorMessage.includes("authentication") ||
+                            errorMessage.includes("Unauthorized")))) return [3 /*break*/, 9];
+                    _a.label = 3;
+                case 3:
+                    _a.trys.push([3, 8, , 9]);
+                    console.log("🔄 Token expired during upload, refreshing...");
+                    return [4 /*yield*/, getToken()];
+                case 4:
+                    newToken = _a.sent();
+                    if (!newToken) return [3 /*break*/, 7];
+                    return [4 /*yield*/, client.connectWithOAuthToken(newToken)];
+                case 5:
+                    _a.sent();
+                    return [4 /*yield*/, client.upload(file)];
+                case 6:
+                    result = _a.sent();
+                    console.log("✅ Upload succeeded after token refresh");
+                    return [2 /*return*/, result];
+                case 7: return [3 /*break*/, 9];
+                case 8:
+                    refreshError_2 = _a.sent();
+                    console.error("❌ Token refresh failed:", refreshError_2);
+                    return [3 /*break*/, 9];
+                case 9:
+                    error_5 = {
                         code: "UPLOAD_FAILED",
                         message: "Failed to upload file",
                         details: err_5,
                     };
-                    setError(error_3);
-                    throw error_3;
-                case 3:
+                    setError(error_5);
+                    throw error_5;
+                case 10:
                     setIsLoading(false);
                     return [7 /*endfinally*/];
-                case 4: return [2 /*return*/];
+                case 11: return [2 /*return*/];
             }
         });
     }); };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trainly/react",
-  "version": "1.1.0",
+  "version": "1.1.3",
   "description": "Dead simple RAG integration for React apps with OAuth authentication",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",