@pol-studios/powersync 1.0.25 → 1.0.32

package/dist/{chunk-CACKC6XG.js → chunk-PGEDE6IM.js}

@@ -17,8 +17,8 @@ var PolStorageAdapter = class {
     this.remoteStorage = options.remoteStorage;
     this.attachmentDirectoryName = options.attachmentDirectoryName ?? "attachments";
     this.logger = options.logger;
-    const cacheDir = this.platform.fileSystem.getCacheDirectory();
-    this.userStorageDirectory = cacheDir.endsWith("/") ? `${cacheDir}${this.attachmentDirectoryName}/` : `${cacheDir}/${this.attachmentDirectoryName}/`;
+    const documentsDir = this.platform.fileSystem.getDocumentsDirectory();
+    this.userStorageDirectory = documentsDir.endsWith("/") ? `${documentsDir}${this.attachmentDirectoryName}/` : `${documentsDir}/${this.attachmentDirectoryName}/`;
   }
   // ─── Remote Operations ──────────────────────────────────────────────────────
   /**
@@ -31,6 +31,23 @@ var PolStorageAdapter = class {
     const base64 = this._arrayBufferToBase64(data);
     await this.remoteStorage.uploadFile(filePath, base64);
   }
+  /**
+   * Convert base64 string to Blob with error handling.
+   * Throws a descriptive error if the base64 data is malformed.
+   */
+  _base64ToBlob(base64String, filePath) {
+    try {
+      const binaryString = atob(base64String);
+      const bytes = new Uint8Array(binaryString.length);
+      for (let i = 0; i < binaryString.length; i++) {
+        bytes[i] = binaryString.charCodeAt(i);
+      }
+      return new Blob([bytes]);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`[PolStorageAdapter] Failed to decode base64 for file "${filePath}": ${message}. The file data may be corrupted or incorrectly encoded.`);
+    }
+  }
   /**
    * Download a file from remote storage.
    *
@@ -47,19 +64,9 @@ var PolStorageAdapter = class {
       if (result.startsWith("file://")) {
         this.logger?.warn(`[PolStorageAdapter] PERFORMANCE WARNING: file:// path hit in downloadFile() - reading entire file into memory. This should be avoided; use direct file copy instead. File: ${filePath}`);
         const base64Content = await this.platform.fileSystem.readFile(result, "base64");
-        const binaryString2 = atob(base64Content);
-        const bytes2 = new Uint8Array(binaryString2.length);
-        for (let i = 0; i < binaryString2.length; i++) {
-          bytes2[i] = binaryString2.charCodeAt(i);
-        }
-        return new Blob([bytes2]);
+        return this._base64ToBlob(base64Content, filePath);
       }
-      const binaryString = atob(result);
-      const bytes = new Uint8Array(binaryString.length);
-      for (let i = 0; i < binaryString.length; i++) {
-        bytes[i] = binaryString.charCodeAt(i);
-      }
-      return new Blob([bytes]);
+      return this._base64ToBlob(result, filePath);
     }
     return result;
   }
@@ -120,7 +127,7 @@ var PolStorageAdapter = class {
   }
   /**
    * Get the user's storage directory for attachments.
-   * Returns the cache directory path ending with '/'.
+   * Returns the documents directory path ending with '/'.
    */
   getUserStorageDirectory() {
     return this.userStorageDirectory;
@@ -141,12 +148,17 @@ var PolStorageAdapter = class {
     return btoa(chunks.join(""));
   }
   _base64ToArrayBuffer(base64) {
-    const binaryString = atob(base64);
-    const bytes = new Uint8Array(binaryString.length);
-    for (let i = 0; i < binaryString.length; i++) {
-      bytes[i] = binaryString.charCodeAt(i);
+    try {
+      const binaryString = atob(base64);
+      const bytes = new Uint8Array(binaryString.length);
+      for (let i = 0; i < binaryString.length; i++) {
+        bytes[i] = binaryString.charCodeAt(i);
+      }
+      return bytes.buffer;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`[PolStorageAdapter] Failed to decode base64 data: ${message}. The data may be corrupted or incorrectly encoded.`);
     }
-    return bytes.buffer;
   }
 };
 
@@ -161,7 +173,6 @@ var PolAttachmentState = /* @__PURE__ */ ((PolAttachmentState2) => {
   PolAttachmentState2[PolAttachmentState2["SYNCED"] = 3] = "SYNCED";
   PolAttachmentState2[PolAttachmentState2["ARCHIVED"] = 4] = "ARCHIVED";
   PolAttachmentState2[PolAttachmentState2["FAILED_PERMANENT"] = 5] = "FAILED_PERMANENT";
-  PolAttachmentState2[PolAttachmentState2["DOWNLOAD_SKIPPED"] = 6] = "DOWNLOAD_SKIPPED";
   return PolAttachmentState2;
 })(PolAttachmentState || {});
 var DEFAULT_COMPRESSION_CONFIG = {
@@ -221,6 +232,27 @@ function formatCacheSize(bytes) {
   }
   return `${bytes} bytes`;
 }
+function resolveBucketFromConfig(config) {
+  if (config.source && config.source.type === "supabase-bucket") {
+    return config.source.bucket;
+  }
+  return void 0;
+}
+function isSignedUrlSource(config) {
+  if (config.source && config.source.type === "supabase-bucket") {
+    return config.source.signed !== false;
+  }
+  return true;
+}
+function isCustomSource(config) {
+  return config.source?.type === "custom";
+}
+function getCustomUrlResolver(config) {
+  if (config.source?.type === "custom") {
+    return config.source.getUrl;
+  }
+  return void 0;
+}
 
 // src/attachments/state-machine.ts
 import { AttachmentState as AttachmentState2 } from "@powersync/attachments";
@@ -482,17 +514,21 @@ async function downloadRecord(deps, record) {
     deps.notify(true);
     return true;
   } catch (e) {
+    const errorMessage = e instanceof Error ? e.message : String(e);
+    logger.warn(`[DownloadManager] Download failed for "${record.id}": ${errorMessage}`);
     if (deps.onDownloadError) {
       const {
         retry
       } = await deps.onDownloadError(record, e);
       if (!retry) {
+        logger.info(`[DownloadManager] Archiving "${record.id}" after download error (retry=false)`);
         await deps.update({
           ...record,
           state: AttachmentState3.ARCHIVED
         });
         return true;
       }
+      logger.debug(`[DownloadManager] Will retry "${record.id}" on next cycle (retry=true)`);
     }
   }
   return false;
@@ -514,6 +550,9 @@ function isPermanentError(error) {
   }
   return false;
 }
+function hasStatusCode(e) {
+  return e instanceof Error && ("status" in e || "statusCode" in e);
+}
 function extractErrorCode(error) {
   const message = error.message;
   const patterns = [
@@ -532,8 +571,13 @@ function extractErrorCode(error) {
       return match[1];
     }
   }
-  if ("status" in error && typeof error.status === "number") {
-    return String(error.status);
+  if (hasStatusCode(error)) {
+    if (typeof error.status === "number") {
+      return String(error.status);
+    }
+    if (typeof error.statusCode === "string") {
+      return error.statusCode;
+    }
   }
   return void 0;
 }
@@ -1028,20 +1072,22 @@ async function getLocalUriForStoragePath(deps, storagePath, storage) {
       return null;
     }
   } catch (e) {
-    logger.warn(`[CacheManager] Failed to verify file exists: ${storagePath}`, e);
+    logger.warn(`[CacheManager] Failed to verify file exists, returning null: ${storagePath}`, e);
+    return null;
   }
   return uri;
 }
 async function copyToManagedCache(platform, logger, sourceUri, storagePath) {
   const localPath = storagePath.replace(/[^a-zA-Z0-9._-]/g, "_");
-  const cacheDir = platform.fileSystem.getCacheDirectory();
-  const targetUri = `${cacheDir}upload_queue/${localPath}`;
+  const docsDir = platform.fileSystem.getDocumentsDirectory();
+  const basePath = docsDir.endsWith("/") ? docsDir : `${docsDir}/`;
+  const targetUri = `${basePath}upload_queue/${localPath}`;
   const dir = targetUri.substring(0, targetUri.lastIndexOf("/"));
   await platform.fileSystem.makeDirectory(dir, {
     intermediates: true
   });
   await platform.fileSystem.copyFile(sourceUri, targetUri);
-  logger.info(`[CacheManager] Copied to managed cache: ${targetUri}`);
+  logger.info(`[CacheManager] Copied to documents for upload: ${targetUri}`);
   return targetUri;
 }
 function createCacheManagerDeps(partial) {
@@ -1064,6 +1110,7 @@ var PolAttachmentQueue = class extends AbstractAttachmentQueue2 {
   polLogger;
   source;
   remoteStorage;
+  supabaseClient;
   uploadHandler;
   uploadConfig;
   downloadConfig;
@@ -1075,10 +1122,12 @@ var PolAttachmentQueue = class extends AbstractAttachmentQueue2 {
   _disposed = false;
   _initialized = false;
   _watchGeneration = 0;
-  _watchIdsCleanup = void 0;
+  _watchCleanup = void 0;
   _watchMutex = Promise.resolve();
   _networkListenerCleanup = void 0;
   _wasConnected = null;
+  _cacheCapacityRetries = 0;
+  // Track cache capacity retries to prevent infinite loops
   // Notification state
   _progressCallbacks = /* @__PURE__ */ new Set();
   _lastNotifyTime = 0;
@@ -1103,6 +1152,7 @@ var PolAttachmentQueue = class extends AbstractAttachmentQueue2 {
     this.polLogger = options.platform.logger;
     this.source = options.source;
     this.remoteStorage = options.remoteStorage;
+    this.supabaseClient = options.supabaseClient;
     this.uploadHandler = options.uploadHandler;
     this.uploadConfig = {
       ...DEFAULT_UPLOAD_CONFIG,
@@ -1132,7 +1182,7 @@ var PolAttachmentQueue = class extends AbstractAttachmentQueue2 {
    * The parent implementation deletes SYNCED/ARCHIVED records beyond cacheLimit,
    * which caused a bug where downloads would reset because:
    * 1. expireCache deleted records beyond cacheLimit (default 100)
-   * 2. watchIds still emitted those IDs
+   * 2. watchPaths still emitted those IDs
    * 3. They got re-created as QUEUED_DOWNLOAD
    * 4. Downloads restarted in an infinite loop
    *
@@ -1172,7 +1222,20 @@ var PolAttachmentQueue = class extends AbstractAttachmentQueue2 {
         if (hasMaxSize) {
           const nearCapacity = await isCacheNearCapacity(this._getCacheManagerDeps());
           if (nearCapacity) {
-            this.polLogger?.warn?.(`[PolAttachmentQueue] Cache at ${Math.round(this.cacheConfig.downloadStopThreshold * 100)}% capacity, pausing downloads`);
+            this._cacheCapacityRetries++;
+            const maxRetries = 3;
+            if (this._cacheCapacityRetries >= maxRetries) {
+              this.polLogger?.warn?.(`[PolAttachmentQueue] Cache at capacity, max retries (${maxRetries}) reached. ${this.downloadQueue.size} items pending, waiting for next watchPaths emission.`);
+              this._cacheCapacityRetries = 0;
+            } else {
+              const delay = 5e3 * this._cacheCapacityRetries;
+              this.polLogger?.warn?.(`[PolAttachmentQueue] Cache at ${Math.round(this.cacheConfig.downloadStopThreshold * 100)}% capacity. ${this.downloadQueue.size} items pending, retry ${this._cacheCapacityRetries}/${maxRetries} in ${delay / 1e3}s.`);
+              setTimeout(() => {
+                if (!this._disposed && this.downloadQueue.size > 0) {
+                  this._downloadRecordsConcurrent();
+                }
+              }, delay);
+            }
             break;
           }
         }
@@ -1191,6 +1254,13 @@ var PolAttachmentQueue = class extends AbstractAttachmentQueue2 {
             }
           } catch (err) {
             this.polLogger?.warn?.(`[PolAttachmentQueue] Download failed for ${id}:`, err);
+            const error = err instanceof Error ? err : new Error(String(err));
+            if (isPermanentError(error)) {
+              this.polLogger?.info?.(`[PolAttachmentQueue] Not retrying ${id} (permanent error)`);
+            } else {
+              this.polLogger?.debug?.(`[PolAttachmentQueue] Re-queuing ${id} for retry (transient error)`);
+              this.downloadQueue.add(id);
+            }
           }
         });
         await Promise.all(downloadPromises);
@@ -1207,45 +1277,23 @@ var PolAttachmentQueue = class extends AbstractAttachmentQueue2 {
   }
   async watchAttachmentIds() {
     this.onAttachmentIdsChange(async (ids) => {
-      const generation = ++this._watchGeneration;
-      this.polLogger?.debug?.(`[PolAttachmentQueue] Received ${ids.length} attachment IDs from watch`);
-      let filteredIds = ids;
-      let skippedIds = [];
-      if (this.source.skipDownload && ids.length > 0) {
-        try {
-          const context = {
-            ids,
-            db: this.powersync
-          };
-          skippedIds = await this.source.skipDownload(context);
-          if (generation !== this._watchGeneration) {
-            this.polLogger?.debug?.("[PolAttachmentQueue] Stale watch callback, ignoring");
-            return;
-          }
-          const skipSet = new Set(skippedIds);
-          filteredIds = ids.filter((id) => !skipSet.has(id));
-          this.polLogger?.info?.(`[PolAttachmentQueue] Pre-filtered: ${ids.length} total, ${skippedIds.length} skipped, ${filteredIds.length} to sync`);
-        } catch (error) {
-          this.polLogger?.warn?.("[PolAttachmentQueue] skipDownload filter failed, using all IDs:", error);
-          filteredIds = ids;
-          skippedIds = [];
-        }
-      }
-      this.polLogger?.debug?.(`[PolAttachmentQueue] Syncing attachment IDs: [${filteredIds.length} items]`);
+      this.polLogger?.debug?.(`[PolAttachmentQueue] Received ${ids.length} attachment paths from watch`);
+      this.polLogger?.debug?.(`[PolAttachmentQueue] Syncing attachment paths: [${ids.length} items]`);
+      this._cacheCapacityRetries = 0;
       if (this.initialSync) {
         this.initialSync = false;
-        if (filteredIds.length > 0) {
-          const placeholders = filteredIds.map(() => "?").join(",");
+        if (ids.length > 0) {
+          const placeholders = ids.map(() => "?").join(",");
           await this.powersync.execute(`UPDATE ${this.table}
              SET state = ${AttachmentState6.QUEUED_SYNC}
              WHERE state < ${AttachmentState6.SYNCED}
-               AND state NOT IN (${AttachmentState6.QUEUED_UPLOAD}, ${5 /* FAILED_PERMANENT */}, ${6 /* DOWNLOAD_SKIPPED */})
-               AND id IN (${placeholders})`, filteredIds);
+               AND state NOT IN (${AttachmentState6.QUEUED_UPLOAD}, ${5 /* FAILED_PERMANENT */})
+               AND id IN (${placeholders})`, ids);
         }
       }
       const attachmentsInDatabase = await this.powersync.getAll(`SELECT * FROM ${this.table} WHERE state < ${AttachmentState6.ARCHIVED}`);
       const attachmentsMap = new Map(attachmentsInDatabase.map((r) => [r.id, r]));
-      for (const id of filteredIds) {
+      for (const id of ids) {
         const record = attachmentsMap.get(id);
         if (!record) {
           const newRecord = await this.newAttachmentRecord({
@@ -1257,7 +1305,6 @@ var PolAttachmentQueue = class extends AbstractAttachmentQueue2 {
         }
         if (PROTECTED_UPLOAD_STATES.has(record.state)) continue;
         if (record.upload_source_uri) continue;
-        if (record.state === 6 /* DOWNLOAD_SKIPPED */) continue;
         if (record.local_uri == null || !await this.storage.fileExists(this.getLocalUri(record.local_uri))) {
           await this.update({
             ...record,
@@ -1265,22 +1312,14 @@ var PolAttachmentQueue = class extends AbstractAttachmentQueue2 {
           });
         }
       }
-      if (skippedIds.length > 0) {
-        const placeholders = skippedIds.map(() => "?").join(",");
-        await this.powersync.execute(`UPDATE ${this.table}
-           SET state = ${6 /* DOWNLOAD_SKIPPED */}
-           WHERE id IN (${placeholders})
-             AND state NOT IN (${AttachmentState6.QUEUED_UPLOAD}, ${5 /* FAILED_PERMANENT */}, ${AttachmentState6.SYNCED})`, skippedIds);
-      }
-      const allValidIds = [.../* @__PURE__ */ new Set([...filteredIds, ...skippedIds])];
-      if (allValidIds.length > 0) {
-        const placeholders = allValidIds.map(() => "?").join(",");
+      if (ids.length > 0) {
+        const placeholders = ids.map(() => "?").join(",");
         await this.powersync.execute(`UPDATE ${this.table}
            SET state = ${AttachmentState6.ARCHIVED}
            WHERE state < ${AttachmentState6.ARCHIVED}
              AND state NOT IN (${AttachmentState6.QUEUED_UPLOAD}, ${5 /* FAILED_PERMANENT */})
              AND upload_source_uri IS NULL
-             AND id NOT IN (${placeholders})`, allValidIds);
+             AND id NOT IN (${placeholders})`, ids);
       }
       this._invalidateStatsCache();
       this._notify(true);
@@ -1314,21 +1353,25 @@ var PolAttachmentQueue = class extends AbstractAttachmentQueue2 {
   onAttachmentIdsChange(onUpdate) {
     this._watchMutex = this._watchMutex.then(async () => {
       if (this._disposed) return;
-      if (this._watchIdsCleanup) {
+      if (this._watchCleanup) {
         try {
-          this._watchIdsCleanup();
+          this._watchCleanup();
         } catch (error) {
           this.polLogger?.warn?.("[PolAttachmentQueue] Watch cleanup failed:", error);
         }
-        this._watchIdsCleanup = void 0;
+        this._watchCleanup = void 0;
       }
       try {
-        const cleanup = this.source.watchIds(this.powersync, onUpdate);
+        if (!this.source.watchPaths) {
+          this.polLogger?.warn?.("[PolAttachmentQueue] No watchPaths callback provided");
+          return;
+        }
+        const cleanup = this.source.watchPaths(this.powersync, this.supabaseClient, onUpdate);
         if (typeof cleanup === "function") {
-          this._watchIdsCleanup = cleanup;
+          this._watchCleanup = cleanup;
         }
       } catch (error) {
-        this.polLogger?.warn?.("[PolAttachmentQueue] watchIds failed:", error);
+        this.polLogger?.warn?.("[PolAttachmentQueue] watchPaths callback failed:", error);
       }
     }).catch((err) => {
       this.polLogger?.warn?.("[PolAttachmentQueue] Watch mutex error:", err);
@@ -1413,13 +1456,13 @@ var PolAttachmentQueue = class extends AbstractAttachmentQueue2 {
   dispose() {
     this._disposed = true;
     this._uploadState.abortController.abort();
-    if (this._watchIdsCleanup) {
+    if (this._watchCleanup) {
       try {
-        this._watchIdsCleanup();
+        this._watchCleanup();
       } catch (error) {
-        this.polLogger?.warn?.("[PolAttachmentQueue] watchIds cleanup failed:", error);
+        this.polLogger?.warn?.("[PolAttachmentQueue] watchPaths cleanup failed:", error);
       }
-      this._watchIdsCleanup = void 0;
+      this._watchCleanup = void 0;
     }
     if (this._networkListenerCleanup) {
       try {
@@ -1756,7 +1799,7 @@ var PolAttachmentQueue = class extends AbstractAttachmentQueue2 {
     }
     const rows = await this.powersync.getAll(`SELECT state, COUNT(*) as cnt, COALESCE(SUM(size), 0) as sz
        FROM ${this.table} GROUP BY state`);
-    let synced = 0, syncedSize = 0, pending = 0, pendingUpload = 0, failedPermanent = 0, skippedDownloadCount = 0;
+    let synced = 0, syncedSize = 0, pending = 0, pendingUpload = 0, failedPermanent = 0;
     for (const r of rows) {
       if (r.state === AttachmentState6.SYNCED) {
         synced = r.cnt;
@@ -1765,7 +1808,6 @@ var PolAttachmentQueue = class extends AbstractAttachmentQueue2 {
       if (r.state === AttachmentState6.QUEUED_DOWNLOAD || r.state === AttachmentState6.QUEUED_SYNC) pending += r.cnt;
       if (r.state === AttachmentState6.QUEUED_UPLOAD) pendingUpload = r.cnt;
       if (r.state === 5 /* FAILED_PERMANENT */) failedPermanent = r.cnt;
-      if (r.state === 6 /* DOWNLOAD_SKIPPED */) skippedDownloadCount = r.cnt;
     }
     const staleUploads = await this.getStaleUploads();
     const stats = {
@@ -1786,7 +1828,8 @@ var PolAttachmentQueue = class extends AbstractAttachmentQueue2 {
       failedPermanentCount: failedPermanent,
       staleUploadCount: staleUploads.length,
       activeUploads: this.activeUploads,
-      skippedDownloadCount
+      skippedDownloadCount: 0
+      // No longer tracked - filtering should happen in watchPaths
     };
     this._cachedStats = stats;
     this._cachedStatsTimestamp = now;
@@ -1970,10 +2013,10 @@ function createPolAttachmentQueue(powersync, platform, config) {
     storage: void 0,
     platform,
     remoteStorage: config.remoteStorage,
+    supabaseClient: config.supabaseClient,
     source: {
-      bucket: config.bucket,
-      watchIds: config.watchIds,
-      skipDownload: config.skipDownload
+      source: config.source,
+      watchPaths: config.watchPaths
     },
     attachmentDirectoryName: "attachments",
     attachmentTableName: "attachments",
@@ -2003,6 +2046,10 @@ export {
   DEFAULT_CACHE_CONFIG,
   CACHE_SIZE_PRESETS,
   formatCacheSize,
+  resolveBucketFromConfig,
+  isSignedUrlSource,
+  isCustomSource,
+  getCustomUrlResolver,
   ATTACHMENT_TABLE,
   AttachmentState,
   AttachmentTable,
@@ -2058,4 +2105,4 @@ export {
   PolAttachmentQueue,
   createPolAttachmentQueue
 };
-//# sourceMappingURL=chunk-CACKC6XG.js.map
+//# sourceMappingURL=chunk-PGEDE6IM.js.map