@pol-studios/powersync 1.0.24 → 1.0.30

package/README.md

@@ -512,7 +512,6 @@ function FailedUploads() {
     permanentErrorCount,
     retryFailure,
     clearFailure,
-    clearAllFailures,
   } = useFailedTransactionsContext();
 
   if (!hasUploadErrors) return null;

package/dist/attachments/index.d.ts

@@ -5,7 +5,7 @@ export { ATTACHMENT_TABLE, AbstractAttachmentQueue, AttachmentState, AttachmentT
 import { PlatformAdapter, LoggerAdapter } from '../platform/index.js';
 import { AbstractPowerSyncDatabase } from '@powersync/common';
 export { AbstractPowerSyncDatabase as PowerSyncDBInterface } from '@powersync/common';
-import '../types-CDqWh56B.js';
+import '../types-Dv1uf0LZ.js';
 
 /**
  * POL Storage Adapter

package/dist/{background-sync-ChCXW-EV.d.ts → background-sync-CVR3PkFi.d.ts}

@@ -1,4 +1,4 @@
-import { a as SyncStatus, S as SyncMode, e as SyncMetrics, b as ConnectionHealth, f as SyncError } from './types-CDqWh56B.js';
+import { a as SyncStatus, S as SyncMode, e as SyncMetrics, b as ConnectionHealth, f as SyncError } from './types-Dv1uf0LZ.js';
 
 /**
  * Sync Module Types for @pol-studios/powersync

package/dist/{chunk-BGBQYQV3.js → chunk-BC2SRII2.js}

@@ -1,10 +1,6 @@
-import {
-  withExponentialBackoff
-} from "./chunk-FV2HXEIY.js";
 import {
   classifySupabaseError,
-  extractHttpStatusCode,
-  isRlsError
+  extractHttpStatusCode
 } from "./chunk-I2AYMY5O.js";
 
 // src/connector/types.ts
@@ -13,31 +9,20 @@ var DEFAULT_RETRY_CONFIG = {
   transient: {
     maxRetries: 3,
     baseDelayMs: 1e3,
-    // 1 second initial delay
     maxDelayMs: 4e3,
-    // 4 second cap
     backoffMultiplier: 2
-    // 1s → 2s → 4s
   },
   permanent: {
     maxRetries: 0,
-    // No retries - permanent errors won't succeed
     baseDelayMs: 1e3,
-    // Irrelevant with 0 retries, but needed for type
     maxDelayMs: 1e3,
-    // Irrelevant with 0 retries
     backoffMultiplier: 1
-    // Irrelevant with 0 retries
   },
   rls: {
-    maxRetries: 5,
-    // Extended retries for RLS errors
-    baseDelayMs: 3e4,
-    // 30 seconds initial delay
-    maxDelayMs: 12e4,
-    // 2 minutes max delay
-    backoffMultiplier: 2
-    // 30s → 60s → 120s → 120s → 120s
+    maxRetries: 0,
+    baseDelayMs: 1e3,
+    maxDelayMs: 1e3,
+    backoffMultiplier: 1
   }
 };
 
@@ -377,8 +362,6 @@ var SupabaseConnector = class _SupabaseConnector {
   versionColumnPromises = /* @__PURE__ */ new Map();
   // Flag to track if connector has been destroyed
   isDestroyed = false;
-  // Retry configuration
-  retryConfig;
   // Track completion failures for circuit breaker logic
   // Maps transaction fingerprint (hash of entry IDs) to failure tracking info
   completionFailures = /* @__PURE__ */ new Map();
@@ -386,13 +369,6 @@ var SupabaseConnector = class _SupabaseConnector {
   static COMPLETION_EXTENDED_TIMEOUT_MS = 6e4;
   // 60s timeout for retry
   static MAX_STORED_RESOLUTIONS = 100;
-  autoRetryPaused = false;
-  // Per-entry cooldown tracking for failed operations
-  // Maps entry key (table:id) to the timestamp when it can be retried
-  entryCooldowns = /* @__PURE__ */ new Map();
-  static COOLDOWN_DURATION_MS = 6e4;
-  // 1 minute cooldown after exhausting retries
-  static MAX_ENTRY_COOLDOWNS = 200;
   // Upload error middleware chain
   uploadErrorMiddleware;
   constructor(options) {
@@ -408,20 +384,6 @@ var SupabaseConnector = class _SupabaseConnector {
     this.conflictDetection = options.conflictDetection;
     this.conflictHandler = options.conflictHandler;
     this.conflictBus = options.conflictBus;
-    this.retryConfig = {
-      transient: {
-        ...DEFAULT_RETRY_CONFIG.transient,
-        ...options.retryConfig?.transient
-      },
-      permanent: {
-        ...DEFAULT_RETRY_CONFIG.permanent,
-        ...options.retryConfig?.permanent
-      },
-      rls: {
-        ...DEFAULT_RETRY_CONFIG.rls,
-        ...options.retryConfig?.rls
-      }
-    };
     this.uploadErrorMiddleware = options.uploadErrorMiddleware ?? [];
     if (this.conflictBus) {
       this.unsubscribeResolution = this.conflictBus.onResolution((table, recordId, resolution) => {
@@ -464,80 +426,46 @@ var SupabaseConnector = class _SupabaseConnector {
     const sortedIds = entries.map((e) => `${e.table}:${e.id}`).sort();
     return sortedIds.join("|");
   }
-  // ─── Retry Control Methods ─────────────────────────────────────────────────
+  // ─── Simplified Entry Processing ───────────────────────────────────────────
+  //
+  // Architecture:
+  // - NO internal retry loops - PowerSync SDK handles all retries naturally
+  // - Middleware decides once: success/discard/retry/fail_transaction
+  // - 'retry' = transient error, throw to let PowerSync retry on next sync cycle
+  // - 'fail_transaction' = permanent error, throw immediately with failure callback
+  // - 'discard' = silently skip via DiscardEntryError
+  // - 'success' = treat as completed, return normally
+  //
+  // This keeps error handling simple and lets the user configure middleware
+  // to decide what to do with each error type.
   /**
-   * Pause automatic retry of failed uploads.
-   * Use this when the user goes offline intentionally or wants manual control.
-   */
-  pauseAutoRetry() {
-    this.autoRetryPaused = true;
-    if (__DEV__) {
-      console.log("[Connector] Auto-retry paused");
-    }
-  }
-  /**
-   * Resume automatic retry of failed uploads.
-   */
-  resumeAutoRetry() {
-    this.autoRetryPaused = false;
-    if (__DEV__) {
-      console.log("[Connector] Auto-retry resumed");
-    }
-  }
-  // ─── Private Retry Logic ───────────────────────────────────────────────────
-  /**
-   * Process a single CRUD entry with exponential backoff retry.
-   *
-   * This method uses a two-phase approach:
-   * 1. First attempt - try the operation to classify the error type
-   * 2. Retry phase - use the appropriate config (transient vs permanent) based on classification
+   * Process a single CRUD entry once (no internal retries).
    *
-   * This fixes the issue where reassigning selectedConfig inside withExponentialBackoff's
-   * callback had no effect because the config was already destructured at call time.
+   * On failure, middleware classifies the error:
+   * - 'success': Treat as completed (e.g., idempotent duplicate)
+   * - 'discard': Remove from queue silently
+   * - 'retry': Throw to let PowerSync retry on next sync cycle
+   * - 'fail_transaction': Throw TransactionAbortError immediately
+   * - 'continue': Throw original error (PowerSync will retry)
    *
    * @param entry - The CRUD entry to process
-   * @throws Error if all retries exhausted (for critical failures)
+   * @throws Error for all errors (PowerSync will retry)
+   * @throws TransactionAbortError when middleware returns 'fail_transaction'
+   * @throws DiscardEntryError for discarded entries
    */
-  async processWithRetry(entry) {
+  async processEntryOnce(entry) {
     if (this.isDestroyed) {
       throw new Error("Connector destroyed");
     }
-    const entryKey = `${entry.table}:${entry.id}`;
-    const cooldownUntil = this.entryCooldowns.get(entryKey);
-    if (cooldownUntil) {
-      if (Date.now() >= cooldownUntil) {
-        this.entryCooldowns.delete(entryKey);
-      } else {
-        const remainingMs = cooldownUntil - Date.now();
-        if (__DEV__) {
-          console.log("[Connector] Entry in cooldown, skipping:", {
-            table: entry.table,
-            id: entry.id,
-            remainingSec: Math.round(remainingMs / 1e3)
-          });
-        }
-        throw new Error(`Entry in cooldown for ${Math.round(remainingMs / 1e3)}s`);
-      }
-    }
-    const classified = {
-      isPermanent: false,
-      pgCode: void 0,
-      userMessage: ""
-    };
-    let lastError;
     try {
       await this.processCrudEntry(entry);
-      this.entryCooldowns.delete(entryKey);
       return;
     } catch (error) {
-      lastError = error instanceof Error ? error : new Error(String(error));
       const classifiedError = classifySupabaseError(error);
-      classified.isPermanent = classifiedError.isPermanent;
-      classified.pgCode = classifiedError.pgCode;
-      classified.userMessage = classifiedError.userMessage;
+      const errorObj = error instanceof Error ? error : new Error(String(error));
       if (isAuthError(error)) {
         if (__DEV__) {
-          console.log("[Connector] Auth error detected, refreshing session before retry:", {
+          console.log("[Connector] Auth error detected, refreshing session:", {
             table: entry.table,
             op: entry.op,
             id: entry.id
@@ -546,164 +474,99 @@ var SupabaseConnector = class _SupabaseConnector {
         try {
           await this.supabase.auth.refreshSession();
           await this.processCrudEntry(entry);
-          this.entryCooldowns.delete(entryKey);
           return;
         } catch (retryError) {
-          lastError = retryError instanceof Error ? retryError : new Error(String(retryError));
-          const retriedClassification = classifySupabaseError(retryError);
-          classified.isPermanent = retriedClassification.isPermanent;
-          classified.pgCode = retriedClassification.pgCode;
-          classified.userMessage = retriedClassification.userMessage;
-        }
-      }
-      if (__DEV__) {
-        console.log("[Connector] Initial attempt failed, will retry with appropriate config:", {
-          table: entry.table,
-          op: entry.op,
-          id: entry.id,
-          isPermanent: classified.isPermanent,
-          pgCode: classified.pgCode,
-          userMessage: classified.userMessage
-        });
-      }
-      this.logger?.warn("[Connector] Initial attempt failed:", {
-        table: entry.table,
-        op: entry.op,
-        id: entry.id,
-        error: lastError.message,
-        isPermanent: classified.isPermanent
-      });
-      if (this.uploadErrorMiddleware.length > 0) {
-        const classifiedError2 = classifySupabaseError(error);
-        const schema = this.schemaRouter(entry.table);
-        const middlewareContext = {
-          entry,
-          error: lastError,
-          pgCode: classified.pgCode,
-          httpStatusCode: extractHttpStatusCode(error),
-          classified: classifiedError2,
-          originalError: error,
-          schema,
-          supabase: this.supabase
-        };
-        const middlewareResult = await runUploadErrorMiddleware(
-          middlewareContext,
-          this.uploadErrorMiddleware,
-          "continue"
-          // Default to continue if no middleware matches
-        );
-        if (__DEV__) {
-          console.log("[Connector] Upload error middleware result:", {
-            table: entry.table,
-            id: entry.id,
-            result: middlewareResult
-          });
-        }
-        switch (middlewareResult) {
-          case "success":
-            this.entryCooldowns.delete(entryKey);
-            this.logger?.info("[Connector] Entry treated as success by middleware:", {
-              table: entry.table,
-              id: entry.id,
-              pgCode: classified.pgCode
-            });
-            return;
-          case "discard":
-            this.entryCooldowns.delete(entryKey);
-            this.logger?.warn("[Connector] Entry discarded by middleware:", {
-              table: entry.table,
-              id: entry.id,
-              pgCode: classified.pgCode,
-              error: lastError.message
-            });
-            throw new DiscardEntryError(`Entry discarded by middleware: ${entry.table}:${entry.id} (${classified.pgCode || "unknown"})`);
-          case "retry":
-            break;
-          case "continue":
-            break;
-          case "fail_transaction":
-            this.logger?.error("[Connector] Transaction aborted by middleware:", {
-              table: entry.table,
-              id: entry.id,
-              pgCode: classified.pgCode,
-              error: lastError.message
-            });
-            throw new TransactionAbortError(`Transaction aborted by middleware: ${entry.table}:${entry.id}`, lastError);
+          const retryClassified = classifySupabaseError(retryError);
+          return this.handleEntryError(entry, retryError instanceof Error ? retryError : new Error(String(retryError)), retryClassified, retryError);
         }
       }
+      return this.handleEntryError(entry, errorObj, classifiedError, error);
     }
-    const isRlsPermissionError = lastError && isRlsError(lastError);
-    const selectedConfig = isRlsPermissionError ? this.retryConfig.rls : classified.isPermanent ? this.retryConfig.permanent : this.retryConfig.transient;
-    if (__DEV__ && isRlsPermissionError) {
-      console.log("[Connector] RLS/permission error detected, using extended retry config:", {
+  }
+  /**
+   * Handle an entry error by running middleware and deciding what to do.
+   */
+  async handleEntryError(entry, error, classified, originalError) {
+    if (__DEV__) {
+      console.log("[Connector] Entry failed:", {
         table: entry.table,
         op: entry.op,
         id: entry.id,
-        maxRetries: selectedConfig.maxRetries,
-        baseDelayMs: selectedConfig.baseDelayMs,
-        maxDelayMs: selectedConfig.maxDelayMs
+        isPermanent: classified.isPermanent,
+        pgCode: classified.pgCode,
+        message: error.message
       });
     }
-    try {
-      await withExponentialBackoff(async () => {
-        await this.processCrudEntry(entry);
-      }, selectedConfig, {
-        onRetry: (attempt, delay, error) => {
-          this.logger?.debug("[Connector] Retry attempt:", {
-            table: entry.table,
-            op: entry.op,
-            id: entry.id,
-            attempt,
-            delay,
-            error: error.message
-          });
-          if (__DEV__) {
-            console.log("[Connector] Retry attempt:", {
-              table: entry.table,
-              op: entry.op,
-              id: entry.id,
-              attempt,
-              maxRetries: selectedConfig.maxRetries,
-              delayMs: delay,
-              errorMessage: error.message
-            });
-          }
-        }
-      });
-      this.entryCooldowns.delete(entryKey);
-    } catch (error) {
-      const finalError = error instanceof Error ? error : new Error(String(error));
-      const category = classified.isPermanent ? "permanent" : classified.pgCode ? "transient" : "unknown";
+    this.logger?.warn("[Connector] Entry failed:", {
+      table: entry.table,
+      op: entry.op,
+      id: entry.id,
+      error: error.message,
+      isPermanent: classified.isPermanent
+    });
+    let middlewareResult = "continue";
+    if (this.uploadErrorMiddleware.length > 0) {
+      const schema = this.schemaRouter(entry.table);
+      const middlewareContext = {
+        entry,
+        error,
+        pgCode: classified.pgCode,
+        httpStatusCode: extractHttpStatusCode(originalError),
+        classified,
+        originalError,
+        schema,
+        supabase: this.supabase
+      };
+      middlewareResult = await runUploadErrorMiddleware(middlewareContext, this.uploadErrorMiddleware, "continue");
       if (__DEV__) {
-        console.log("[Connector] CRUD entry failed after retries, leaving in ps_crud:", {
+        console.log("[Connector] Middleware result:", {
           table: entry.table,
-          op: entry.op,
           id: entry.id,
-          category,
-          error: finalError.message
+          result: middlewareResult
         });
       }
-      this.logger?.error("[Connector] CRUD entry failed after retries:", {
-        table: entry.table,
-        op: entry.op,
-        id: entry.id,
-        error: finalError.message,
-        category
-      });
-      const cooldownMs = _SupabaseConnector.COOLDOWN_DURATION_MS;
-      if (this.entryCooldowns.size >= _SupabaseConnector.MAX_ENTRY_COOLDOWNS) {
-        const firstKey = this.entryCooldowns.keys().next().value;
-        if (firstKey) this.entryCooldowns.delete(firstKey);
-      }
-      this.entryCooldowns.set(entryKey, Date.now() + cooldownMs);
-      if (__DEV__) {
-        console.log("[Connector] Entry placed in cooldown:", {
+    }
+    switch (middlewareResult) {
+      case "success":
+        this.logger?.info("[Connector] Entry treated as success by middleware:", {
           table: entry.table,
           id: entry.id,
-          cooldownSec: cooldownMs / 1e3
+          pgCode: classified.pgCode
         });
-      }
-      throw finalError;
+        return;
+      case "discard":
+        this.logger?.warn("[Connector] Entry discarded by middleware:", {
+          table: entry.table,
+          id: entry.id,
+          pgCode: classified.pgCode
+        });
+        throw new DiscardEntryError(`Entry discarded by middleware: ${entry.table}:${entry.id} (${classified.pgCode || "unknown"})`);
+      case "fail_transaction":
+        this.logger?.error("[Connector] Transaction aborted by middleware:", {
+          table: entry.table,
+          id: entry.id,
+          pgCode: classified.pgCode
+        });
+        throw new TransactionAbortError(`Transaction aborted by middleware: ${entry.table}:${entry.id}`, error);
+      case "retry":
+        if (__DEV__) {
+          console.log("[Connector] Middleware returned retry - throwing for PowerSync retry:", {
+            table: entry.table,
+            id: entry.id
+          });
+        }
+        throw error;
+      case "continue":
+      default:
+        if (__DEV__) {
+          console.log("[Connector] Error - throwing for PowerSync retry:", {
+            table: entry.table,
+            id: entry.id,
+            isPermanent: classified.isPermanent,
+            pgCode: classified.pgCode
+          });
+        }
+        throw error;
     }
   }
   /**
@@ -951,17 +814,23 @@ var SupabaseConnector = class _SupabaseConnector {
       return;
     }
     const successfulEntries = [];
-    for (const entry of entriesToProcess) {
-      if (__DEV__) {
-        console.log("[Connector] Processing CRUD entry with retry:", {
-          table: entry.table,
-          op: entry.op,
-          id: entry.id,
-          opData: entry.opData
-        });
+    try {
+      for (const entry of entriesToProcess) {
+        if (__DEV__) {
+          console.log("[Connector] Processing CRUD entry:", {
+            table: entry.table,
+            op: entry.op,
+            id: entry.id,
+            opData: entry.opData
+          });
+        }
+        await this.processEntryOnce(entry);
+        successfulEntries.push(entry);
       }
-      await this.processWithRetry(entry);
-      successfulEntries.push(entry);
+    } catch (error) {
+      const classified = classifySupabaseError(error);
+      this.onTransactionFailure?.(entriesToProcess, error instanceof Error ? error : new Error(String(error)), classified);
+      throw error;
     }
     await this.finalizeTransaction({
       transaction,
@@ -1147,50 +1016,56 @@ var SupabaseConnector = class _SupabaseConnector {
         }]))
       });
     }
-    for (const [table, entries] of entriesByTable) {
-      const schema = this.schemaRouter(table);
-      const putEntries = entries.filter((e) => e.op === "PUT" /* PUT */);
-      const patchEntries = entries.filter((e) => e.op === "PATCH" /* PATCH */);
-      const deleteEntries = entries.filter((e) => e.op === "DELETE" /* DELETE */);
-      if (this.crudHandler) {
-        for (const entry of entries) {
-          try {
-            await this.processWithRetry(entry);
-            successfulEntries.push(entry);
-          } catch (error) {
-            if (error instanceof DiscardEntryError) {
-              discardedEntries.push(entry);
-              continue;
+    try {
+      for (const [table, entries] of entriesByTable) {
+        const schema = this.schemaRouter(table);
+        const putEntries = entries.filter((e) => e.op === "PUT" /* PUT */);
+        const patchEntries = entries.filter((e) => e.op === "PATCH" /* PATCH */);
+        const deleteEntries = entries.filter((e) => e.op === "DELETE" /* DELETE */);
+        if (this.crudHandler) {
+          for (const entry of entries) {
+            try {
+              await this.processEntryOnce(entry);
+              successfulEntries.push(entry);
+            } catch (error) {
+              if (error instanceof DiscardEntryError) {
+                discardedEntries.push(entry);
+                continue;
+              }
+              throw error;
             }
-            throw error;
           }
+          continue;
+        }
+        if (putEntries.length > 0) {
+          const {
+            successful,
+            discarded
+          } = await this.processBatchedPuts(table, schema, putEntries);
+          successfulEntries.push(...successful);
+          discardedEntries.push(...discarded);
+        }
+        if (deleteEntries.length > 0) {
+          const {
+            successful,
+            discarded
+          } = await this.processBatchedDeletes(table, schema, deleteEntries);
+          successfulEntries.push(...successful);
+          discardedEntries.push(...discarded);
+        }
+        if (patchEntries.length > 0) {
+          const {
+            successful,
+            discarded
+          } = await this.processBatchedPatches(table, schema, patchEntries);
+          successfulEntries.push(...successful);
+          discardedEntries.push(...discarded);
         }
-        continue;
-      }
-      if (putEntries.length > 0) {
-        const {
-          successful,
-          discarded
-        } = await this.processBatchedPuts(table, schema, putEntries);
-        successfulEntries.push(...successful);
-        discardedEntries.push(...discarded);
-      }
-      if (deleteEntries.length > 0) {
-        const {
-          successful,
-          discarded
-        } = await this.processBatchedDeletes(table, schema, deleteEntries);
-        successfulEntries.push(...successful);
-        discardedEntries.push(...discarded);
-      }
-      if (patchEntries.length > 0) {
-        const {
-          successful,
-          discarded
-        } = await this.processBatchedPatches(table, schema, patchEntries);
-        successfulEntries.push(...successful);
-        discardedEntries.push(...discarded);
       }
+    } catch (error) {
+      const classified = classifySupabaseError(error);
+      this.onTransactionFailure?.(transaction.crud, error instanceof Error ? error : new Error(String(error)), classified);
+      throw error;
     }
     await this.finalizeTransaction({
       transaction,
@@ -1235,7 +1110,7 @@ var SupabaseConnector = class _SupabaseConnector {
       }
       for (const entry of entries) {
         try {
-          await this.processWithRetry(entry);
+          await this.processEntryOnce(entry);
           successful.push(entry);
         } catch (e) {
           if (e instanceof DiscardEntryError) {
@@ -1292,7 +1167,7 @@ var SupabaseConnector = class _SupabaseConnector {
       }
       for (const entry of entries) {
         try {
-          await this.processWithRetry(entry);
+          await this.processEntryOnce(entry);
           successful.push(entry);
         } catch (e) {
           if (e instanceof DiscardEntryError) {
@@ -1347,7 +1222,7 @@ var SupabaseConnector = class _SupabaseConnector {
       }
       const results = await Promise.all(batch.map(async (entry) => {
         try {
-          await this.processWithRetry(entry);
+          await this.processEntryOnce(entry);
           return {
             status: "success",
             entry
@@ -1497,7 +1372,9 @@ var SupabaseConnector = class _SupabaseConnector {
               errorHint: upsertError.hint
             });
           }
-          throw new Error(`Upsert failed for ${schema}.${table}: ${upsertError.message}`);
+          const upsertErr = new Error(`Upsert failed for ${schema}.${table}: ${upsertError.message}`);
+          upsertErr.code = upsertError.code;
+          throw upsertErr;
         }
         if (__DEV__) {
           console.log("[Connector] PUT/UPSERT SUCCESS:", {
@@ -1534,7 +1411,9 @@ var SupabaseConnector = class _SupabaseConnector {
               errorHint: updateError.hint
             });
           }
-          throw new Error(`Update failed for ${schema}.${table}: ${updateError.message}`);
+          const updateErr = new Error(`Update failed for ${schema}.${table}: ${updateError.message}`);
+          updateErr.code = updateError.code;
+          throw updateErr;
         }
         if (__DEV__) {
           console.log("[Connector] PATCH/UPDATE SUCCESS:", {
@@ -1570,7 +1449,9 @@ var SupabaseConnector = class _SupabaseConnector {
               errorHint: deleteError.hint
             });
           }
-          throw new Error(`Delete failed for ${schema}.${table}: ${deleteError.message}`);
+          const deleteErr = new Error(`Delete failed for ${schema}.${table}: ${deleteError.message}`);
+          deleteErr.code = deleteError.code;
+          throw deleteErr;
         }
         if (__DEV__) {
           console.log("[Connector] DELETE SUCCESS:", {
@@ -1607,4 +1488,4 @@ export {
   getLocalVersion,
   SupabaseConnector
 };
-//# sourceMappingURL=chunk-BGBQYQV3.js.map
+//# sourceMappingURL=chunk-BC2SRII2.js.map