@oxyhq/services 5.8.10 → 5.9.0

package/src/core/index.ts

@@ -66,7 +66,6 @@ export class OxyServices {
   private client: AxiosInstance;
   private accessToken: string | null = null;
   private refreshToken: string | null = null;
-  private refreshPromise: Promise<{ accessToken: string; refreshToken: string }> | null = null;
 
   /**
    * Creates a new instance of the OxyServices client
@@ -82,14 +81,25 @@ export class OxyServices {
     this.client.interceptors.request.use(async (req: InternalAxiosRequestConfig) => {
       if (!this.accessToken) {
         return req;
-      }        // Check if token is expired and refresh if needed
-        try {
-          const decoded = jwtDecode<JwtPayload>(this.accessToken);
-          const currentTime = Math.floor(Date.now() / 1000);
-        
+      }
+      
+      // Check if token is expired and refresh if needed
+      try {
+        const decoded = jwtDecode<JwtPayload>(this.accessToken);
+        const currentTime = Math.floor(Date.now() / 1000);
+      
         // If token expires in less than 60 seconds, refresh it
         if (decoded.exp - currentTime < 60) {
-          await this.refreshTokens();
+          // For session-based tokens, get a new token from the session
+          if (decoded.sessionId) {
+            try {
+              const res = await this.client.get(`/secure-session/token/${decoded.sessionId}`);
+              this.accessToken = res.data.accessToken;
+            } catch (refreshError) {
+              // If refresh fails, clear tokens
+              this.clearTokens();
+            }
+          }
         }
       } catch (error) {
         // If token can't be decoded, continue with request and let server handle it
@@ -109,19 +119,25 @@ export class OxyServices {
         // If the error is due to an expired token and we haven't tried refreshing yet
         if (
           error.response?.status === 401 &&
-          this.refreshToken &&
+          this.accessToken &&
           originalRequest &&
           !originalRequest.headers?.['X-Retry-After-Refresh']
         ) {
           try {
-            await this.refreshTokens();
-            // Retry the original request with new token
-            const newRequest = { ...originalRequest };
-            if (newRequest.headers) {
-              newRequest.headers.Authorization = `Bearer ${this.accessToken}`;
-              newRequest.headers['X-Retry-After-Refresh'] = 'true';
+            // Check if token is session-based and try to refresh
+            const decoded = jwtDecode<JwtPayload>(this.accessToken);
+            if (decoded.sessionId) {
+              const res = await this.client.get(`/secure-session/token/${decoded.sessionId}`);
+              this.accessToken = res.data.accessToken;
+              
+              // Retry the original request with new token
+              const newRequest = { ...originalRequest };
+              if (newRequest.headers) {
+                newRequest.headers.Authorization = `Bearer ${this.accessToken}`;
+                newRequest.headers['X-Retry-After-Refresh'] = 'true';
+              }
+              return this.client(newRequest);
             }
-            return this.client(newRequest);
           } catch (refreshError) {
             // If refresh fails, force user to login again
             this.clearTokens();
@@ -156,44 +172,17 @@ export class OxyServices {
   }
 
   /**
-   * Gets the currently authenticated user ID from the token
-   * @returns The user ID or null if not authenticated
-   */
-  public getCurrentUserId(): string | null {
-    if (!this.accessToken) return null;
-    
-    try {
-      const decoded = jwtDecode<JwtPayload>(this.accessToken);
-      
-      // Check for both userId (preferred) and id (fallback) for compatibility
-      return decoded.userId || (decoded as any).id || null;
-    } catch (error) {
-      return null;
-    }
-  }
-  
-  /**
-   * Internal method to check if we have an access token
-   * @private
-   * @returns Boolean indicating if access token exists
-   * @internal - Use `isAuthenticated` from useOxy() context in UI components instead
+   * Set authentication tokens manually
+   * @param accessToken - The access token
+   * @param refreshToken - The refresh token (optional for session-based auth)
    */
-  private hasAccessToken(): boolean {
-    return this.accessToken !== null;
-  }
-
-  /**
-   * Sets authentication tokens directly (useful for initializing from storage)
-   * @param accessToken - JWT access token
-   * @param refreshToken - Refresh token for getting new access tokens
-   */
-  public setTokens(accessToken: string, refreshToken: string): void {
+  public setTokens(accessToken: string, refreshToken: string = ''): void {
     this.accessToken = accessToken;
     this.refreshToken = refreshToken;
   }
-  
+
   /**
-   * Clears all authentication tokens
+   * Clear stored authentication tokens
    */
   public clearTokens(): void {
     this.accessToken = null;
@@ -201,89 +190,28 @@ export class OxyServices {
   }
 
   /**
-   * Sign up a new user
-   * @param username - Desired username
-   * @param email - User's email address
-   * @param password - User's password
-   * @returns Object containing the message, token and user data
+   * Get the current user ID from the stored token
+   * @returns User ID or null if not authenticated
    */
-  async signUp(username: string, email: string, password: string): Promise<{ message: string; token: string; user: User }> {
-    try {
-      const res = await this.client.post('/auth/signup', { username, email, password });
-      const { message, token, user } = res.data;
-      this.accessToken = token;
-      return { message, token, user };
-    } catch (error) {
-      throw this.handleError(error);
-    }
-  }
-
-  /**
-   * Log in and store tokens
-   * @param username - User's username or email
-   * @param password - User's password
-   * @returns Login response containing tokens and user data
-   */
-  async login(username: string, password: string): Promise<LoginResponse> {
-    try {
-      const res = await this.client.post('/auth/login', { username, password });
-      const { accessToken, refreshToken, user } = res.data;
-      this.accessToken = accessToken;
-      this.refreshToken = refreshToken;
-      return { accessToken, refreshToken, user };
-    } catch (error) {
-      throw this.handleError(error);
-    }
-  }
-
-  /**
-   * Log out user
-   */
-  async logout(): Promise<void> {
-    if (!this.refreshToken) return;
+  public getCurrentUserId(): string | null {
+    if (!this.accessToken) return null;
     
     try {
-      await this.client.post('/auth/logout', { refreshToken: this.refreshToken });
+      const decoded = jwtDecode<JwtPayload>(this.accessToken);
+      return decoded.userId || decoded.id || null;
     } catch (error) {
-      console.warn('Error during logout', error);
-    } finally {
-      this.accessToken = null;
-      this.refreshToken = null;
+      return null;
     }
   }
-
+  
   /**
-   * Refresh access and refresh tokens
-   * @returns New tokens
+   * Internal method to check if we have an access token
+   * @private
+   * @returns Boolean indicating if access token exists
+   * @internal - Use `isAuthenticated` from useOxy() context in UI components instead
    */
-  async refreshTokens(): Promise<{ accessToken: string; refreshToken: string }> {
-    if (!this.refreshToken) {
-      throw new Error('No refresh token available');
-    }
-    
-    // If a refresh is already in progress, return that promise
-    if (this.refreshPromise) {
-      return this.refreshPromise;
-    }
-    
-    // Create a new refresh promise
-    this.refreshPromise = (async () => {
-      try {
-        const res = await this.client.post('/auth/refresh', { refreshToken: this.refreshToken });
-        const { accessToken, refreshToken } = res.data;
-        this.accessToken = accessToken;
-        this.refreshToken = refreshToken;
-        return { accessToken, refreshToken };
-      } catch (error) {
-        this.accessToken = null;
-        this.refreshToken = null;
-        throw this.handleError(error);
-      } finally {
-        this.refreshPromise = null;
-      }
-    })();
-    
-    return this.refreshPromise;
+  private hasAccessToken(): boolean {
+    return this.accessToken !== null;
   }
 
   /**
@@ -292,6 +220,22 @@ export class OxyServices {
    */
   async validate(): Promise<boolean> {
     try {
+      // Check if token contains sessionId (new session-based system)
+      if (this.accessToken) {
+        try {
+          const decoded = jwtDecode<JwtPayload>(this.accessToken);
+          if (decoded.sessionId) {
+            // Use session-based validation
+            const res = await this.client.get(`/secure-session/validate/${decoded.sessionId}`);
+            return res.data.valid;
+          }
+        } catch (decodeError) {
+          // If token can't be decoded, fall back to old validation
+          console.warn('Error decoding JWT token for session validation:', decodeError);
+        }
+      }
+      
+      // Fall back to old validation method
       const res = await this.client.get('/auth/validate');
       return res.data.valid;
     } catch (error) {
@@ -301,59 +245,6 @@ export class OxyServices {
 
   /* Session Management Methods */
 
-  /**
-   * Get active sessions for the authenticated user
-   * @returns Array of active session objects
-   */
-  async getUserSessions(): Promise<any[]> {
-    try {
-      const res = await this.client.get('/sessions');
-      return res.data;
-    } catch (error) {
-      throw this.handleError(error);
-    }
-  }
-
-  /**
-   * Logout from a specific session
-   * @param sessionId - The session ID to logout from
-   * @returns Success status
-   */
-  async logoutSession(sessionId: string): Promise<{ success: boolean; message: string }> {
-    try {
-      const res = await this.client.delete(`/sessions/${sessionId}`);
-      return res.data;
-    } catch (error) {
-      throw this.handleError(error);
-    }
-  }
-
-  /**
-   * Logout from all other sessions (keep current session active)
-   * @returns Success status
-   */
-  async logoutOtherSessions(): Promise<{ success: boolean; message: string }> {
-    try {
-      const res = await this.client.post('/sessions/logout-others');
-      return res.data;
-    } catch (error) {
-      throw this.handleError(error);
-    }
-  }
-
-  /**
-   * Logout from all sessions
-   * @returns Success status
-   */
-  async logoutAllSessions(): Promise<{ success: boolean; message: string }> {
-    try {
-      const res = await this.client.post('/sessions/logout-all');
-      return res.data;
-    } catch (error) {
-      throw this.handleError(error);
-    }
-  }
-
   /**
    * Get device sessions for a specific session ID
    * @param sessionId - The session ID to get device sessions for
@@ -1177,12 +1068,41 @@ export class OxyServices {
   }
 
   /**
-   * Secure login that returns only session data (no tokens stored locally)
+   * Sign up a new user and create a session
+   * @param username - Desired username
+   * @param email - User's email address
+   * @param password - User's password
+   * @returns Object containing the message, token and user data
+   */
+  async signUp(username: string, email: string, password: string): Promise<{ message: string; token: string; user: User }> {
+    try {
+      // First, create the user account
+      const res = await this.client.post('/secure-session/register', { username, email, password });
+      const { message, user } = res.data;
+      
+      // Then log them in to create a session
+      const loginRes = await this.secureLogin(username, password);
+      
+      // Get the access token for the session
+      const tokenRes = await this.getTokenBySession(loginRes.sessionId);
+      
+      return { 
+        message, 
+        token: tokenRes.accessToken, 
+        user: loginRes.user as User
+      };
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Secure login that creates a device-based session
    * @param username - User's username or email
    * @param password - User's password
-   * @param deviceName - Optional device name for session tracking
-   * @param deviceFingerprint - Device fingerprint for enhanced security
-   * @returns Secure login response with session data
+   * @param deviceName - Optional device name
+   * @param deviceFingerprint - Optional device fingerprint
+   * @returns Login response with session data
    */
   async secureLogin(username: string, password: string, deviceName?: string, deviceFingerprint?: any): Promise<SecureLoginResponse> {
     try {
@@ -1395,19 +1315,50 @@ export class OxyServices {
           });
         }
         
-        // Create a temporary OxyServices instance with the token to validate it
-        const tempOxyServices = new OxyServices({
-          baseURL: this.client.defaults.baseURL || ''
-        });
-        tempOxyServices.setTokens(token, ''); // Set access token
-        
-        // Validate token using the validate method
-        const isValid = await tempOxyServices.validate();
+        // Check if token contains sessionId (new session-based system)
+        let isValid = false;
+        let userId: string | null = null;
         
-        if (!isValid) {
+        try {
+          const decoded = jwtDecode<JwtPayload>(token);
+          userId = decoded.userId || decoded.id;
+          
+          if (decoded.sessionId) {
+            // Use session-based validation
+            const tempOxyServices = new OxyServices({
+              baseURL: this.client.defaults.baseURL || ''
+            });
+            tempOxyServices.setTokens(token, '');
+            
+            const validation = await tempOxyServices.validateSession(decoded.sessionId);
+            isValid = validation.valid;
+            
+            if (isValid && loadFullUser) {
+              req.user = validation.user;
+            }
+          } else {
+            // Use old validation method
+            const tempOxyServices = new OxyServices({
+              baseURL: this.client.defaults.baseURL || ''
+            });
+            tempOxyServices.setTokens(token, '');
+            
+            isValid = await tempOxyServices.validate();
+            
+            if (isValid && loadFullUser) {
+              try {
+                const userProfile = await tempOxyServices.getUserById(userId!);
+                req.user = userProfile;
+              } catch (userError) {
+                // If we can't load user, continue with just ID
+                req.user = { id: userId };
+              }
+            }
+          }
+        } catch (decodeError) {
           const error = {
-            message: 'Invalid or expired token',
-            code: 'INVALID_TOKEN',
+            message: 'Invalid token payload',
+            code: 'INVALID_PAYLOAD',
             status: 403
           };
           
@@ -1416,20 +1367,15 @@ export class OxyServices {
           }
           
           return res.status(403).json({ 
-            message: 'Invalid or expired token',
-            code: 'INVALID_TOKEN'
+            message: 'Invalid token payload',
+            code: 'INVALID_PAYLOAD'
           });
         }
         
-        // Get user ID from token using JWT decode instead of relying on getCurrentUserId
-        let userId: string | null = null;
-        try {
-          const decoded = jwtDecode<JwtPayload>(token);
-          userId = decoded.userId || decoded.id;
-        } catch (decodeError) {
+        if (!isValid) {
           const error = {
-            message: 'Invalid token payload',
-            code: 'INVALID_PAYLOAD',
+            message: 'Invalid or expired token',
+            code: 'INVALID_TOKEN',
             status: 403
           };
           
@@ -1438,8 +1384,8 @@ export class OxyServices {
           }
           
           return res.status(403).json({ 
-            message: 'Invalid token payload',
-            code: 'INVALID_PAYLOAD'
+            message: 'Invalid or expired token',
+            code: 'INVALID_TOKEN'
           });
         }
         
@@ -1464,16 +1410,8 @@ export class OxyServices {
         req.userId = userId;
         req.accessToken = token;
         
-        // Optionally load full user data
-        if (loadFullUser) {
-          try {
-            const userProfile = await tempOxyServices.getUserById(userId);
-            req.user = userProfile;
-          } catch (userError) {
-            // If we can't load user, continue with just ID
-            req.user = { id: userId };
-          }
-        } else {
+        // Set user object if not already set by session validation
+        if (!req.user) {
           req.user = { id: userId };
         }
         
@@ -1513,55 +1451,76 @@ export class OxyServices {
         };
       }
       
-      // Create a temporary OxyServices instance with the token
-      const tempOxyServices = new OxyServices({
-        baseURL: this.client.defaults.baseURL || ''
-      });
-      tempOxyServices.setTokens(token, '');
-      
-      // Validate token
-      const isValid = await tempOxyServices.validate();
-      
-      if (!isValid) {
-        return {
-          valid: false,
-          error: 'Invalid or expired token'
-        };
-      }
-      
-      // Get user ID from token using JWT decode
-      let userId: string | null = null;
+      // Check if token contains sessionId (new session-based system)
       try {
         const decoded = jwtDecode<JwtPayload>(token);
-        userId = decoded.userId || decoded.id;
+        const userId = decoded.userId || decoded.id;
+        
+        if (decoded.sessionId) {
+          // Use session-based validation
+          const tempOxyServices = new OxyServices({
+            baseURL: this.client.defaults.baseURL || ''
+          });
+          tempOxyServices.setTokens(token, '');
+          
+          const validation = await tempOxyServices.validateSession(decoded.sessionId);
+          
+          if (validation.valid) {
+            return {
+              valid: true,
+              userId,
+              user: validation.user
+            };
+          } else {
+            return {
+              valid: false,
+              error: 'Invalid or expired session'
+            };
+          }
+        } else {
+          // Use old validation method
+          const tempOxyServices = new OxyServices({
+            baseURL: this.client.defaults.baseURL || ''
+          });
+          tempOxyServices.setTokens(token, '');
+          
+          const isValid = await tempOxyServices.validate();
+          
+          if (!isValid) {
+            return {
+              valid: false,
+              error: 'Invalid or expired token'
+            };
+          }
+          
+          if (!userId) {
+            return {
+              valid: false,
+              error: 'Invalid token payload'
+            };
+          }
+          
+          // Try to get user profile
+          let user;
+          try {
+            user = await tempOxyServices.getUserById(userId);
+          } catch (error) {
+            // Continue without full user data
+            user = { id: userId };
+          }
+          
+          return {
+            valid: true,
+            userId,
+            user
+          };
+        }
       } catch (decodeError) {
         return {
           valid: false,
           error: 'Invalid token payload'
         };
       }
-      
-      if (!userId) {
-        return {
-          valid: false,
-          error: 'Invalid token payload'
-        };
-      }
-      
-      // Try to get user profile
-      let user;
-      try {
-        user = await tempOxyServices.getUserById(userId);
-      } catch (error) {
-        // Continue without full user data
-        user = { id: userId };
-      }
-      
-      return {
-        valid: true,
-        userId,
-        user
-      };
     } catch (error) {
       return {
         valid: false,

package/src/node/index.ts

@@ -4,15 +4,11 @@
 
 // ------------- Core Imports -------------
 import { OxyServices, OXY_CLOUD_URL } from '../core'; // Adjusted path
-import { createAuth } from './createAuth';
 import * as Models from '../models/interfaces'; // Adjusted path
 
 // ------------- Core Exports -------------
 export { OxyServices, OXY_CLOUD_URL };
 
-// Zero-config auth and session router
-export { createAuth };
-
 // ------------- Model Exports -------------
 export { Models };  // Export all models as a namespace
 export * from '../models/interfaces'; // Export all models directly

package/src/ui/screens/FeedbackScreen.tsx

@@ -1034,8 +1034,6 @@ const FeedbackScreen: React.FC<BaseScreenProps> = ({
         <KeyboardAvoidingView
             style={[styles.container, { backgroundColor: colors.background }]}
             behavior={Platform.OS === 'ios' ? 'padding' : 'height'}
-            keyboardVerticalOffset={Platform.OS === 'ios' ? 0 : 20}
-            enabled={Platform.OS !== 'web'}
         >
             <StatusBar
                 barStyle={theme === 'dark' ? 'light-content' : 'dark-content'}
@@ -1046,8 +1044,6 @@ const FeedbackScreen: React.FC<BaseScreenProps> = ({
                 contentContainerStyle={styles.scrollContent}
                 showsVerticalScrollIndicator={false}
                 keyboardShouldPersistTaps="handled"
-                keyboardDismissMode="interactive"
-                automaticallyAdjustKeyboardInsets={Platform.OS === 'ios'}
             >
                 {feedbackState.status !== 'success' && (
                     <ProgressIndicator currentStep={currentStep} totalSteps={4} colors={colors} styles={styles} />

package/src/ui/screens/RecoverAccountScreen.tsx

@@ -108,8 +108,6 @@ const RecoverAccountScreen: React.FC<RecoverAccountScreenProps> = ({ navigate, g
         <KeyboardAvoidingView
             style={[styles.container, { backgroundColor: colors.background }]}
             behavior={Platform.OS === 'ios' ? 'padding' : 'height'}
-            keyboardVerticalOffset={Platform.OS === 'ios' ? 0 : 20}
-            enabled={Platform.OS !== 'web'}
         >
             <StatusBar
                 barStyle={theme === 'dark' ? 'light-content' : 'dark-content'}
@@ -119,8 +117,6 @@ const RecoverAccountScreen: React.FC<RecoverAccountScreenProps> = ({ navigate, g
                 contentContainerStyle={styles.scrollContent}
                 showsVerticalScrollIndicator={false}
                 keyboardShouldPersistTaps="handled"
-                keyboardDismissMode="interactive"
-                automaticallyAdjustKeyboardInsets={Platform.OS === 'ios'}
             >
                 <Animated.View style={[
                     styles.stepContainer,