sync rate limit

Author: 0xGingi

src/services/apiService.ts

@@ -18,20 +18,30 @@
     }
 
     static async healthCheck(serverUrl: string): Promise<boolean> {
+      // Check if we're currently rate limited
+      const rateLimitUntil = localStorage.getItem('rate_limit_until');
+      if (rateLimitUntil && Date.now() < parseInt(rateLimitUntil, 10)) {
+        console.log('Skipping health check due to active rate limit');
+        throw new Error('Rate limited, please try again later');
+      }
+      
       try {
         const endpoint = this.getEndpoint(serverUrl, '/health');
         const response = await fetch(endpoint, {
+          method: 'GET',
           headers: {
             'Accept': 'application/json',
           },
         });
 
-        if (!response.ok) {
-          throw new Error('Health check failed');
+        if (response.status === 429) {
+          const retryAfter = response.headers.get('Retry-After');
+          const waitTime = retryAfter ? parseInt(retryAfter, 10) * 1000 : 30000;
+          localStorage.setItem('rate_limit_until', (Date.now() + waitTime).toString());
+          return false;
         }
 
-        const data = await response.json();
-        return data.status === 'healthy' && data.database === 'connected';
+        return response.ok;
       } catch (error) {
         console.error('Health check failed:', error);
         return false;
@@ -62,7 +72,8 @@
           body: JSON.stringify({
             public_key: publicKey,
             notes: encryptedNotes,
-            client_version: '0.2.0'
+            client_version: '0.2.0',
+            sync_type: encryptedNotes.length > 0 ? 'full' : 'check' // Indicate if this is just a check
           }),
         });
 
@@ -72,6 +83,18 @@
           headers: Object.fromEntries(response.headers.entries())
         });
 
+        // Handle rate limiting with retry-after header
+        if (response.status === 429) {
+          const retryAfter = response.headers.get('Retry-After');
+          const waitTime = retryAfter ? parseInt(retryAfter, 10) * 1000 : 30000;
+          console.log(`Rate limited. Server requested wait of ${waitTime/1000} seconds`);
+          
+          // Store the rate limit info for future requests
+          localStorage.setItem('rate_limit_until', (Date.now() + waitTime).toString());
+          
+          throw new Error(`Too many requests, please try again after ${waitTime/1000} seconds`);
+        }
+    
         if (!response.ok) {
           const errorData = await response.json().catch(() => null);
           throw new Error(errorData?.error || `Sync failed with status ${response.status}`);

src/services/webStorage.ts

@@ -7,6 +7,8 @@ export class WebStorageService {
   private static readonly SETTINGS_KEY = 'sync_settings';
   private static readonly DELETE_RETENTION_DAYS = 1;
   private static crypto: CryptoService | null = null;
+  private static lastSyncTime: number = 0;
+  private static readonly MIN_SYNC_INTERVAL = 5000; // 5 seconds between syncs
 
   static async initializeCrypto(seedPhrase: string) {
     this.crypto = await CryptoService.new(seedPhrase);
@@ -106,6 +108,15 @@ export class WebStorageService {
       throw new Error('Crypto not initialized');
     }
 
+    // Check if we've synced recently
+    const now = Date.now();
+    const timeSinceLastSync = now - this.lastSyncTime;
+    
+    if (timeSinceLastSync < this.MIN_SYNC_INTERVAL) {
+      console.log(`Throttling sync request. Last sync was ${timeSinceLastSync}ms ago.`);
+      await new Promise(resolve => setTimeout(resolve, this.MIN_SYNC_INTERVAL - timeSinceLastSync));
+    }
+    
     let lastError: Error | null = null;
 
     for (let attempt = 0; attempt < retries; attempt++) {
@@ -159,12 +170,24 @@ export class WebStorageService {
 
         localStorage.setItem(this.NOTES_KEY, JSON.stringify(mergedNotes));
         await this.purgeDeletedNotes();
+        
+        // Update last sync time on success
+        this.lastSyncTime = Date.now();
         return;
 
       } catch (error) {
         console.error(`Sync attempt ${attempt + 1} failed:`, error);
         lastError = error as Error;
 
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        
+        if (errorMessage.includes('Too many requests')) {
+          const waitTime = Math.pow(2, attempt + 2) * 1000;
+          console.log(`Rate limited. Waiting ${waitTime/1000} seconds before retry...`);
+          await new Promise(resolve => setTimeout(resolve, waitTime));
+          continue;
+        }
+        
         if (attempt < retries - 1) {
           await new Promise(resolve => 
             setTimeout(resolve, Math.pow(2, attempt) * 1000)