@pol-studios/powersync 1.0.3 → 1.0.6

package/dist/chunk-5FIMA26D.js

@@ -0,0 +1 @@
+//# sourceMappingURL=chunk-5FIMA26D.js.map

package/dist/{chunk-C2RSTGDC.js → chunk-62J2DPKX.js}

@@ -1,9 +1,26 @@
+import {
+  failedUploadStore
+} from "./chunk-PAFBKNL3.js";
 import {
   classifySupabaseError
 } from "./chunk-FPTDATY5.js";
 
 // src/connector/types.ts
 var defaultSchemaRouter = () => "public";
+var DEFAULT_RETRY_CONFIG = {
+  transient: {
+    maxRetries: 3,
+    baseDelayMs: 1e3,
+    maxDelayMs: 3e4,
+    backoffMultiplier: 2
+  },
+  permanent: {
+    maxRetries: 2,
+    baseDelayMs: 5e3,
+    maxDelayMs: 3e5,
+    backoffMultiplier: 3
+  }
+};
 
 // src/conflicts/detect.ts
 var TABLE_NAME_REGEX = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
@@ -112,6 +129,120 @@ async function getLocalVersion(table, recordId, db) {
   return result?._version ?? null;
 }
 
+// src/utils/retry.ts
+var AbortError = class extends Error {
+  constructor(message = "Operation aborted") {
+    super(message);
+    this.name = "AbortError";
+  }
+};
+var RetryExhaustedError = class extends Error {
+  /** The last error that caused the final retry to fail */
+  cause;
+  /** Total number of attempts made */
+  attempts;
+  constructor(cause, attempts) {
+    super(`Retry exhausted after ${attempts} attempt(s): ${cause.message}`);
+    this.name = "RetryExhaustedError";
+    this.cause = cause;
+    this.attempts = attempts;
+  }
+};
+function calculateBackoffDelay(attempt, config) {
+  const {
+    baseDelayMs,
+    maxDelayMs,
+    backoffMultiplier
+  } = config;
+  const safeAttempt = Math.max(0, attempt);
+  const exponentialDelay = baseDelayMs * Math.pow(backoffMultiplier, safeAttempt);
+  return Math.min(exponentialDelay, maxDelayMs);
+}
+function addJitter(delay) {
+  const jitterFactor = 0.9 + Math.random() * 0.2;
+  return Math.round(delay * jitterFactor);
+}
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(new AbortError());
+      return;
+    }
+    if (ms <= 0) {
+      resolve();
+      return;
+    }
+    let timeoutId;
+    const handleAbort = () => {
+      if (timeoutId !== void 0) {
+        clearTimeout(timeoutId);
+      }
+      reject(new AbortError());
+    };
+    if (signal) {
+      signal.addEventListener("abort", handleAbort, {
+        once: true
+      });
+    }
+    timeoutId = setTimeout(() => {
+      if (signal) {
+        signal.removeEventListener("abort", handleAbort);
+      }
+      resolve();
+    }, ms);
+  });
+}
+var DEFAULT_BACKOFF_CONFIG = {
+  maxRetries: 3,
+  baseDelayMs: 1e3,
+  maxDelayMs: 3e4,
+  backoffMultiplier: 2
+};
+async function withExponentialBackoff(fn, config, options) {
+  const {
+    maxRetries,
+    baseDelayMs,
+    maxDelayMs,
+    backoffMultiplier
+  } = config;
+  const {
+    signal,
+    onRetry
+  } = options ?? {};
+  if (signal?.aborted) {
+    throw new AbortError();
+  }
+  const safeMaxRetries = Math.max(0, Math.floor(maxRetries));
+  const totalAttempts = safeMaxRetries + 1;
+  let lastError;
+  for (let attempt = 0; attempt < totalAttempts; attempt++) {
+    if (signal?.aborted) {
+      throw new AbortError();
+    }
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      const isLastAttempt = attempt === totalAttempts - 1;
+      if (isLastAttempt) {
+        break;
+      }
+      if (signal?.aborted) {
+        throw new AbortError();
+      }
+      const baseDelay = calculateBackoffDelay(attempt, {
+        baseDelayMs,
+        maxDelayMs,
+        backoffMultiplier
+      });
+      const delayWithJitter = addJitter(baseDelay);
+      onRetry?.(attempt + 1, delayWithJitter, lastError);
+      await sleep(delayWithJitter, signal);
+    }
+  }
+  throw new RetryExhaustedError(lastError, totalAttempts);
+}
+
 // src/connector/supabase-connector.ts
 var SupabaseConnector = class {
   supabase;
@@ -136,6 +267,9 @@ var SupabaseConnector = class {
   resolvedConflicts = /* @__PURE__ */ new Map();
   // Cleanup function for resolution listener subscription
   unsubscribeResolution;
+  // Retry configuration
+  retryConfig;
+  autoRetryPaused = false;
   constructor(options) {
     this.supabase = options.supabaseClient;
     this.powerSyncUrl = options.powerSyncUrl;
@@ -149,6 +283,16 @@ var SupabaseConnector = class {
     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
+      }
+    };
     if (this.conflictBus) {
       this.unsubscribeResolution = this.conflictBus.onResolution((table, recordId, resolution) => {
         const key = `${table}:${recordId}`;
@@ -175,6 +319,196 @@ var SupabaseConnector = class {
     }
     this.resolvedConflicts.clear();
   }
+  // ─── Retry Control Methods ─────────────────────────────────────────────────
+  /**
+   * 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");
+    }
+  }
+  /**
+   * Manually retry all failed uploads that are ready for retry.
+   * This processes entries from the failed upload store.
+   */
+  async retryFailedUploads() {
+    const retryableUploads = failedUploadStore.getRetryable();
+    if (retryableUploads.length === 0) {
+      if (__DEV__) {
+        console.log("[Connector] No failed uploads ready for retry");
+      }
+      return;
+    }
+    if (__DEV__) {
+      console.log("[Connector] Manually retrying failed uploads:", {
+        count: retryableUploads.length,
+        entries: retryableUploads.map((u) => ({
+          table: u.table,
+          id: u.id,
+          operation: u.operation
+        }))
+      });
+    }
+    for (const upload of retryableUploads) {
+      try {
+        const entry = {
+          table: upload.table,
+          op: upload.operation,
+          id: upload.id,
+          clientId: Date.now(),
+          // Synthetic clientId for retry
+          opData: upload.data
+        };
+        await this.processWithRetry(entry);
+        failedUploadStore.remove(upload.id);
+        if (__DEV__) {
+          console.log("[Connector] Retry succeeded for:", {
+            table: upload.table,
+            id: upload.id
+          });
+        }
+      } catch (error) {
+        if (__DEV__) {
+          console.log("[Connector] Retry failed again for:", {
+            table: upload.table,
+            id: upload.id,
+            error: error instanceof Error ? error.message : String(error)
+          });
+        }
+      }
+    }
+  }
+  /**
+   * Clear all failed uploads from the store.
+   * Use with caution - this discards all pending retries.
+   */
+  clearFailedUploads() {
+    failedUploadStore.clear();
+    if (__DEV__) {
+      console.log("[Connector] Failed uploads cleared");
+    }
+  }
+  /**
+   * Get all failed uploads from the store.
+   */
+  getFailedUploads() {
+    return failedUploadStore.getAll();
+  }
+  // ─── Private Retry Logic ───────────────────────────────────────────────────
+  /**
+   * Process a single CRUD entry with exponential backoff retry.
+   *
+   * @param entry - The CRUD entry to process
+   * @throws Error if all retries exhausted (for critical failures)
+   */
+  async processWithRetry(entry) {
+    const classified = {
+      isPermanent: false,
+      pgCode: void 0,
+      userMessage: ""
+    };
+    let selectedConfig = this.retryConfig.transient;
+    let lastError;
+    try {
+      await withExponentialBackoff(async () => {
+        try {
+          await this.processCrudEntry(entry);
+        } catch (error) {
+          const classifiedError = classifySupabaseError(error);
+          classified.isPermanent = classifiedError.isPermanent;
+          classified.pgCode = classifiedError.pgCode;
+          classified.userMessage = classifiedError.userMessage;
+          if (classifiedError.isPermanent) {
+            selectedConfig = this.retryConfig.permanent;
+          }
+          lastError = error instanceof Error ? error : new Error(String(error));
+          if (__DEV__) {
+            console.log("[Connector] CRUD operation failed, will retry:", {
+              table: entry.table,
+              op: entry.op,
+              id: entry.id,
+              isPermanent: classifiedError.isPermanent,
+              pgCode: classifiedError.pgCode,
+              userMessage: classifiedError.userMessage
+            });
+          }
+          throw error;
+        }
+      }, 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,
+              delayMs: delay,
+              errorMessage: error.message
+            });
+          }
+        }
+      });
+    } catch (error) {
+      const finalError = lastError ?? (error instanceof Error ? error : new Error(String(error)));
+      const category = classified.isPermanent ? "permanent" : classified.pgCode ? "transient" : "unknown";
+      const retryConfig = classified.isPermanent ? this.retryConfig.permanent : this.retryConfig.transient;
+      const nextRetryDelay = calculateBackoffDelay(retryConfig.maxRetries, retryConfig);
+      const nextRetryAt = Date.now() + nextRetryDelay;
+      failedUploadStore.add({
+        table: entry.table,
+        operation: entry.op,
+        data: entry.opData ?? {},
+        error: {
+          message: finalError.message,
+          code: classified.pgCode,
+          category
+        },
+        retryCount: retryConfig.maxRetries,
+        lastAttempt: Date.now(),
+        nextRetryAt
+      });
+      if (__DEV__) {
+        console.log("[Connector] Entry added to failed upload store:", {
+          table: entry.table,
+          op: entry.op,
+          id: entry.id,
+          category,
+          nextRetryAt: new Date(nextRetryAt).toISOString()
+        });
+      }
+      this.logger?.error("[Connector] CRUD entry failed after retries:", {
+        table: entry.table,
+        op: entry.op,
+        id: entry.id,
+        error: finalError.message,
+        category,
+        nextRetryAt
+      });
+      if (classified.isPermanent) {
+        throw finalError;
+      }
+    }
+  }
   /**
    * Set the active project IDs for scoped sync.
    * Call this when user selects/opens projects.
@@ -237,6 +571,44 @@ var SupabaseConnector = class {
       this.logger?.debug("[Connector] Upload skipped - sync mode does not allow uploads");
       return;
     }
+    if (!this.autoRetryPaused) {
+      const retryableUploads = failedUploadStore.getRetryable();
+      if (retryableUploads.length > 0) {
+        if (__DEV__) {
+          console.log("[Connector] Processing retryable failed uploads:", {
+            count: retryableUploads.length
+          });
+        }
+        for (const upload of retryableUploads) {
+          try {
+            const entry = {
+              table: upload.table,
+              op: upload.operation,
+              id: upload.id,
+              clientId: Date.now(),
+              // Synthetic clientId for retry
+              opData: upload.data
+            };
+            await this.processWithRetry(entry);
+            failedUploadStore.remove(upload.id);
+            if (__DEV__) {
+              console.log("[Connector] Retried upload succeeded:", {
+                table: upload.table,
+                id: upload.id
+              });
+            }
+          } catch (error) {
+            if (__DEV__) {
+              console.log("[Connector] Retried upload failed again:", {
+                table: upload.table,
+                id: upload.id,
+                error: error instanceof Error ? error.message : String(error)
+              });
+            }
+          }
+        }
+      }
+    }
     if (__DEV__) {
       console.log("[Connector] uploadData called, fetching next CRUD transaction...");
     }
@@ -400,25 +772,62 @@ var SupabaseConnector = class {
       }
       return;
     }
-    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.processCrudEntry(entry);
-      }
+    const criticalFailures = [];
+    const successfulEntries = [];
+    for (const entry of entriesToProcess) {
       if (__DEV__) {
-        console.log("[Connector] All CRUD entries processed, completing transaction...");
+        console.log("[Connector] Processing CRUD entry with retry:", {
+          table: entry.table,
+          op: entry.op,
+          id: entry.id,
+          opData: entry.opData
+        });
       }
+      try {
+        await this.processWithRetry(entry);
+        successfulEntries.push(entry);
+      } catch (error) {
+        criticalFailures.push({
+          entry,
+          error: error instanceof Error ? error : new Error(String(error))
+        });
+      }
+    }
+    if (criticalFailures.length > 0) {
+      const firstFailure = criticalFailures[0];
+      const classified = classifySupabaseError(firstFailure.error);
+      console.error("[PowerSync Connector] Critical upload failure:", {
+        errorMessage: firstFailure.error.message,
+        classified,
+        isPermanent: classified.isPermanent,
+        criticalCount: criticalFailures.length,
+        successCount: successfulEntries.length,
+        entries: criticalFailures.map((f) => ({
+          table: f.entry.table,
+          op: f.entry.op,
+          id: f.entry.id
+        }))
+      });
+      this.logger?.error("[Connector] Critical upload failure:", {
+        error: firstFailure.error,
+        classified,
+        entries: criticalFailures.map((f) => ({
+          table: f.entry.table,
+          op: f.entry.op,
+          id: f.entry.id
+        }))
+      });
+      this.onTransactionFailure?.(criticalFailures.map((f) => f.entry), firstFailure.error, classified);
+      throw firstFailure.error;
+    }
+    if (__DEV__) {
+      console.log("[Connector] All CRUD entries processed, completing transaction...");
+    }
+    try {
       await transaction.complete();
       if (__DEV__) {
         console.log("[Connector] Transaction completed successfully:", {
-          entriesCount: entriesToProcess.length,
+          entriesCount: successfulEntries.length,
           discardedCount: entriesDiscarded.length
         });
       }
@@ -448,32 +857,32 @@ var SupabaseConnector = class {
           }
         }
       }
-      this.onTransactionSuccess?.(entriesToProcess);
-      this.onTransactionComplete?.(entriesToProcess);
+      this.onTransactionSuccess?.(successfulEntries);
+      this.onTransactionComplete?.(successfulEntries);
     } catch (error) {
       const classified = classifySupabaseError(error);
-      console.error("[PowerSync Connector] Upload FAILED:", {
+      console.error("[PowerSync Connector] Transaction completion FAILED:", {
         errorMessage: error instanceof Error ? error.message : String(error),
         errorKeys: error && typeof error === "object" ? Object.keys(error) : [],
         errorObject: JSON.stringify(error, null, 2),
         classified,
         isPermanent: classified.isPermanent,
-        entries: entriesToProcess.map((e) => ({
+        entries: successfulEntries.map((e) => ({
           table: e.table,
           op: e.op,
           id: e.id
         }))
       });
-      this.logger?.error("[Connector] Upload error:", {
+      this.logger?.error("[Connector] Transaction completion error:", {
         error,
         classified,
-        entries: entriesToProcess.map((e) => ({
+        entries: successfulEntries.map((e) => ({
           table: e.table,
           op: e.op,
           id: e.id
         }))
       });
-      this.onTransactionFailure?.(entriesToProcess, error instanceof Error ? error : new Error(String(error)), classified);
+      this.onTransactionFailure?.(successfulEntries, error instanceof Error ? error : new Error(String(error)), classified);
       throw error;
     }
   }
@@ -482,53 +891,90 @@ var SupabaseConnector = class {
    * Used when conflict detection is disabled.
    */
   async processTransaction(transaction, _database) {
-    try {
-      for (const entry of transaction.crud) {
-        if (__DEV__) {
-          console.log("[Connector] Processing CRUD entry:", {
-            table: entry.table,
-            op: entry.op,
-            id: entry.id,
-            opData: entry.opData
-          });
-        }
-        await this.processCrudEntry(entry);
-      }
+    const criticalFailures = [];
+    const successfulEntries = [];
+    for (const entry of transaction.crud) {
       if (__DEV__) {
-        console.log("[Connector] All CRUD entries processed, completing transaction...");
+        console.log("[Connector] Processing CRUD entry with retry:", {
+          table: entry.table,
+          op: entry.op,
+          id: entry.id,
+          opData: entry.opData
+        });
       }
+      try {
+        await this.processWithRetry(entry);
+        successfulEntries.push(entry);
+      } catch (error) {
+        criticalFailures.push({
+          entry,
+          error: error instanceof Error ? error : new Error(String(error))
+        });
+      }
+    }
+    if (criticalFailures.length > 0) {
+      const firstFailure = criticalFailures[0];
+      const classified = classifySupabaseError(firstFailure.error);
+      console.error("[PowerSync Connector] Critical upload failure:", {
+        errorMessage: firstFailure.error.message,
+        classified,
+        isPermanent: classified.isPermanent,
+        criticalCount: criticalFailures.length,
+        successCount: successfulEntries.length,
+        entries: criticalFailures.map((f) => ({
+          table: f.entry.table,
+          op: f.entry.op,
+          id: f.entry.id
+        }))
+      });
+      this.logger?.error("[Connector] Critical upload failure:", {
+        error: firstFailure.error,
+        classified,
+        entries: criticalFailures.map((f) => ({
+          table: f.entry.table,
+          op: f.entry.op,
+          id: f.entry.id
+        }))
+      });
+      this.onTransactionFailure?.(criticalFailures.map((f) => f.entry), firstFailure.error, classified);
+      throw firstFailure.error;
+    }
+    if (__DEV__) {
+      console.log("[Connector] All CRUD entries processed, completing transaction...");
+    }
+    try {
       await transaction.complete();
       if (__DEV__) {
         console.log("[Connector] Transaction completed successfully:", {
-          entriesCount: transaction.crud.length
+          entriesCount: successfulEntries.length
         });
       }
-      this.onTransactionSuccess?.(transaction.crud);
-      this.onTransactionComplete?.(transaction.crud);
+      this.onTransactionSuccess?.(successfulEntries);
+      this.onTransactionComplete?.(successfulEntries);
     } catch (error) {
       const classified = classifySupabaseError(error);
-      console.error("[PowerSync Connector] Upload FAILED:", {
+      console.error("[PowerSync Connector] Transaction completion FAILED:", {
         errorMessage: error instanceof Error ? error.message : String(error),
         errorKeys: error && typeof error === "object" ? Object.keys(error) : [],
         errorObject: JSON.stringify(error, null, 2),
         classified,
         isPermanent: classified.isPermanent,
-        entries: transaction.crud.map((e) => ({
+        entries: successfulEntries.map((e) => ({
           table: e.table,
           op: e.op,
           id: e.id
         }))
       });
-      this.logger?.error("[Connector] Upload error:", {
+      this.logger?.error("[Connector] Transaction completion error:", {
         error,
         classified,
-        entries: transaction.crud.map((e) => ({
+        entries: successfulEntries.map((e) => ({
           table: e.table,
           op: e.op,
           id: e.id
         }))
       });
-      this.onTransactionFailure?.(transaction.crud, error instanceof Error ? error : new Error(String(error)), classified);
+      this.onTransactionFailure?.(successfulEntries, error instanceof Error ? error : new Error(String(error)), classified);
       throw error;
     }
   }
@@ -717,10 +1163,18 @@ var SupabaseConnector = class {
 
 export {
   defaultSchemaRouter,
+  DEFAULT_RETRY_CONFIG,
   detectConflicts,
   hasVersionColumn,
   fetchServerVersion,
   getLocalVersion,
+  AbortError,
+  RetryExhaustedError,
+  calculateBackoffDelay,
+  addJitter,
+  sleep,
+  DEFAULT_BACKOFF_CONFIG,
+  withExponentialBackoff,
   SupabaseConnector
 };
-//# sourceMappingURL=chunk-C2RSTGDC.js.map
+//# sourceMappingURL=chunk-62J2DPKX.js.map