coffeeinabit 0.0.1

package/cloud_auth.js

@@ -0,0 +1,170 @@
+import axios from 'axios';
+
+export class CloudAuth {
+  constructor() {
+    this.sessionSecret = process.env.SESSION_SECRET || 'coffeeinabit-secret-key-change-in-production';
+  }
+
+  async getLoginUrl(redirectUri) {
+    try {
+      const params = new URLSearchParams({
+        client_id: '4rhqg2pjfhjkq42mr7iilpnmsu',
+        response_type: 'code',
+        redirect_uri: redirectUri,
+        scope: 'openid email profile'
+      });
+      
+      const loginUrl = `https://coffeeinabit.auth.us-east-1.amazoncognito.com/login?${params.toString()}`;
+      
+      return {
+        success: true,
+        loginUrl: loginUrl
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  async exchangeCodeForTokens(code, redirectUri) {
+    try {
+      console.log('[CloudAuth] Received authorization code:', code.substring(0, 10) + '...');
+      console.log('[CloudAuth] Using redirect_uri:', redirectUri);
+      
+      const response = await axios.get(`https://api.coffeeinabit.com/auth/token?code=${encodeURIComponent(code)}&redirect_url=${encodeURIComponent(redirectUri)}`);
+      
+      if (response.data.error) {
+        throw new Error(response.data.error);
+      }
+      
+      const { id_token, access_token, refresh_token } = response.data;
+      
+      return {
+        success: true,
+        tokens: {
+          idToken: id_token,
+          accessToken: access_token,
+          refreshToken: refresh_token
+        },
+        user: this.extractUserFromToken(id_token)
+      };
+    } catch (error) {
+      console.error('[CloudAuth] Token exchange failed:', error.response?.status, error.response?.data);
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  async refreshTokens(refreshToken) {
+    try {
+      const response = await axios.get(
+        `https://api.coffeeinabit.com/auth/refresh?refresh_token=${encodeURIComponent(refreshToken)}`
+      );
+      
+      if (response.data.error) {
+        throw new Error(response.data.error);
+      }
+      
+      return {
+        success: true,
+        tokens: {
+          idToken: response.data.id_token,
+          accessToken: response.data.access_token,
+          refreshToken: response.data.refresh_token || refreshToken
+        },
+        user: this.extractUserFromToken(response.data.id_token)
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  extractUserFromToken(idToken) {
+    if (!idToken) return null;
+    
+    try {
+      const payload = JSON.parse(Buffer.from(idToken.split('.')[1], 'base64').toString());
+      return {
+        email: payload.email || payload['cognito:username'],
+        userId: payload.sub
+      };
+    } catch (error) {
+      console.error('[CloudAuth] Error extracting user from token:', error.message);
+      return null;
+    }
+  }
+
+  isTokenExpired(token) {
+    if (!token) return true;
+    
+    try {
+      const payload = JSON.parse(Buffer.from(token.split('.')[1], 'base64').toString());
+      if (!payload || !payload.exp) return true;
+      
+      const bufferTime = 5 * 60;
+      return payload.exp < (Date.now() / 1000) + bufferTime;
+    } catch (error) {
+      console.error('[CloudAuth] Error checking token expiration:', error.message);
+      return true;
+    }
+  }
+
+  async ensureValidToken(session) {
+    if (!session.tokens?.idToken) {
+      return { valid: false, error: 'No token available' };
+    }
+
+    if (this.isTokenExpired(session.tokens.idToken)) {
+      console.log('[CloudAuth] Token expired or expiring soon, attempting refresh...');
+      
+      if (!session.tokens.refreshToken) {
+        return { valid: false, error: 'No refresh token available' };
+      }
+
+      const result = await this.refreshTokens(session.tokens.refreshToken);
+      
+      if (result.success) {
+        this.storeTokensInSession(session, result.tokens, result.user);
+        return { valid: true };
+      } else {
+        return { valid: false, error: result.error };
+      }
+    }
+
+    return { valid: true };
+  }
+
+  storeTokensInSession(session, tokens, user) {
+    session.tokens = tokens;
+    session.user = user;
+    console.log('[CloudAuth] Tokens stored in session for user:', user?.email);
+  }
+
+  clearSession(session) {
+    session.tokens = null;
+    session.user = null;
+    console.log('[CloudAuth] Session cleared');
+  }
+
+  isAuthenticated(session) {
+    return !!(session.tokens && session.tokens.idToken && session.tokens.accessToken);
+  }
+
+  getAuthStatus(session) {
+    if (this.isAuthenticated(session)) {
+      return {
+        authenticated: true,
+        user: session.user || null
+      };
+    } else {
+      return { authenticated: false };
+    }
+  }
+}