Cleanup demo. Verify local storage.

Author: stevensJourney

Demo/PowerSyncExample/PowerSync/SystemManager.swift

@@ -11,36 +11,45 @@ func getAttachmentsDirectoryPath() throws -> String {
     return documentsURL.appendingPathComponent("attachments").path
 }
 
+let logTag = "SystemManager"
+
 @Observable
 class SystemManager {
     let connector = SupabaseConnector()
     let schema = AppSchema
     let db: PowerSyncDatabaseProtocol
-    
+
     var attachments: AttachmentQueue?
-    
+
     init() {
         db = PowerSyncDatabase(
             schema: schema,
             dbFilename: "powersync-swift.sqlite"
         )
-        attachments = Self.createAttachments(
+        attachments = Self.createAttachmentQueue(
             db: db,
             connector: connector
         )
     }
-    
-    private static func createAttachments(
-            db: PowerSyncDatabaseProtocol,
-            connector: SupabaseConnector
-        ) -> AttachmentQueue? {
-            guard let bucket = connector.getStorageBucket() else {
-                return nil
-            }
 
-            do {
-                let attachmentsDir = try getAttachmentsDirectoryPath()
-                let watchedAttachments = try db.watch(
+    /// Creates an AttachmentQueue if a Supabase Storage bucket has been specified in the config
+    private static func createAttachmentQueue(
+        db: PowerSyncDatabaseProtocol,
+        connector: SupabaseConnector
+    ) -> AttachmentQueue? {
+        guard let bucket = connector.getStorageBucket() else {
+            db.logger.info("No Supabase Storage bucket specified. Skipping attachment queue setup.", tag: logTag)
+            return nil
+        }
+
+        do {
+            let attachmentsDir = try getAttachmentsDirectoryPath()
+
+            return AttachmentQueue(
+                db: db,
+                remoteStorage: SupabaseRemoteStorage(storage: bucket),
+                attachmentsDirectory: attachmentsDir,
+                watchAttachments: { try db.watch(
                     options: WatchOptions(
                         sql: "SELECT photo_id FROM \(TODOS_TABLE) WHERE photo_id IS NOT NULL",
                         parameters: [],
@@ -51,24 +60,16 @@ class SystemManager {
                             )
                         }
                     )
-                )
-
-                return AttachmentQueue(
-                    db: db,
-                    remoteStorage: SupabaseRemoteStorage(storage: bucket),
-                    attachmentsDirectory: attachmentsDir,
-                    watchedAttachments: watchedAttachments
-                )
-            } catch {
-                print("Failed to initialize attachments queue: \(error)")
-                return nil
-            }
+                ) }
+            )
+        } catch {
+            db.logger.error("Failed to initialize attachments queue: \(error)", tag: logTag)
+            return nil
         }
+    }
 
     func connect() async {
         do {
-            // Only for testing purposes
-            try await attachments?.clearQueue()
             try await db.connect(connector: connector)
             try await attachments?.startSync()
         } catch {
@@ -87,8 +88,8 @@ class SystemManager {
     func signOut() async throws {
         try await db.disconnectAndClear()
         try await connector.client.auth.signOut()
+        try await attachments?.stopSyncing()
         try await attachments?.clearQueue()
-        try await attachments?.close()
     }
 
     func watchLists(_ callback: @escaping (_ lists: [ListContent]) -> Void) async {
@@ -121,19 +122,34 @@ class SystemManager {
     }
 
     func deleteList(id: String) async throws {
-        _ = try await db.writeTransaction(callback: { transaction in
+        let attachmentIds = try await db.writeTransaction(callback: { transaction in
+            let attachmentIDs = try transaction.getAll(
+                sql: "SELECT photo_id FROM \(TODOS_TABLE) WHERE list_id = ? AND photo_id IS NOT NULL",
+                parameters: [id]
+            ) { cursor in
+                cursor.getString(index: 0)! // :(
+            } as? [String] // :(
+
             _ = try transaction.execute(
                 sql: "DELETE FROM \(LISTS_TABLE) WHERE id = ?",
                 parameters: [id]
             )
 
-            // Attachments linked to these will be archived and deleted eventually
-            // Attachments should be deleted explicitly if required
             _ = try transaction.execute(
                 sql: "DELETE FROM \(TODOS_TABLE) WHERE list_id = ?",
                 parameters: [id]
             )
+
+            return attachmentIDs ?? [] // :(
         })
+
+        if let attachments {
+            for id in attachmentIds {
+                try await attachments.deleteFile(
+                    attachmentId: id
+                ) { _, _ in }
+            }
+        }
     }
 
     func watchTodos(_ listId: String, _ callback: @escaping (_ todos: [Todo]) -> Void) async {
@@ -214,7 +230,7 @@ class SystemManager {
         }
     }
 
-    func deleteTodoInTX(id: String, tx: ConnectionContext) throws {
+    private func deleteTodoInTX(id: String, tx: ConnectionContext) throws {
         _ = try tx.execute(
             sql: "DELETE FROM \(TODOS_TABLE) WHERE id = ?",
             parameters: [id]

Sources/PowerSync/attachments/Attachment.swift

@@ -2,19 +2,19 @@
 public enum AttachmentState: Int {
     /// The attachment has been queued for download from the cloud storage
     case queuedDownload
-    /// The attachment has been queued for upload to the cloud storage 
+    /// The attachment has been queued for upload to the cloud storage
     case queuedUpload
-    /// The attachment has been queued for delete in the cloud storage (and locally) 
+    /// The attachment has been queued for delete in the cloud storage (and locally)
     case queuedDelete
-    /// The attachment has been synced 
+    /// The attachment has been synced
     case synced
     /// The attachment has been orphaned, i.e., the associated record has been deleted
     case archived
-    
+
     enum AttachmentStateError: Error {
         case invalidState(Int)
     }
-    
+
     static func from(_ rawValue: Int) throws -> AttachmentState {
         guard let state = AttachmentState(rawValue: rawValue) else {
             throw AttachmentStateError.invalidState(rawValue)
@@ -92,21 +92,22 @@ public struct Attachment {
         filename _: String? = nil,
         state: AttachmentState? = nil,
         timestamp _: Int = 0,
-        hasSynced: Int? = 0,
-        localUri: String? = nil,
-        mediaType: String? = nil,
-        size: Int64? = nil,
-        metaData: String? = nil
+        hasSynced: Int?? = 0,
+        localUri: String?? = .none,
+        mediaType: String?? = .none,
+        size: Int64?? = .none,
+        metaData: String?? = .none
     ) -> Attachment {
         return Attachment(
             id: id,
-            filename: filename,
-            state: state ?? self.state,
-            hasSynced: hasSynced ?? self.hasSynced,
-            localUri: localUri ?? self.localUri,
-            mediaType: mediaType ?? self.mediaType,
-            size: size ?? self.size,
-            metaData: metaData ?? self.metaData
+            filename: filename ?? filename,
+            state: state.map { $0 } ?? self.state,
+            timestamp: timestamp > 0 ? timestamp : timestamp,
+            hasSynced: hasSynced.map { $0 } ?? self.hasSynced,
+            localUri: localUri.map { $0 } ?? self.localUri,
+            mediaType: mediaType.map { $0 } ?? self.mediaType,
+            size: size.map { $0 } ?? self.size,
+            metaData: metaData.map { $0 } ?? self.metaData
         )
     }
 

Sources/PowerSync/attachments/AttachmentQueue.swift

@@ -18,8 +18,8 @@ public actor AttachmentQueue {
     /// Directory name for attachments
     private let attachmentsDirectory: String
 
-    /// Stream of watched attachments
-    private let watchedAttachments: AsyncThrowingStream<[WatchedAttachmentItem], Error>
+    /// Closure which creates a Stream of ``WatchedAttachmentItem``
+    private let watchAttachments: () throws -> AsyncThrowingStream<[WatchedAttachmentItem], Error>
 
     /// Local file system adapter
     public let localStorage: LocalStorageAdapter
@@ -79,7 +79,7 @@ public actor AttachmentQueue {
         db: PowerSyncDatabaseProtocol,
         remoteStorage: RemoteStorageAdapter,
         attachmentsDirectory: String,
-        watchedAttachments: AsyncThrowingStream<[WatchedAttachmentItem], Error>,
+        watchAttachments: @escaping () throws -> AsyncThrowingStream<[WatchedAttachmentItem], Error>,
         localStorage: LocalStorageAdapter = FileManagerStorageAdapter(),
         attachmentsQueueTableName: String = defaultTableName,
         errorHandler: SyncErrorHandler? = nil,
@@ -93,7 +93,7 @@ public actor AttachmentQueue {
         self.db = db
         self.remoteStorage = remoteStorage
         self.attachmentsDirectory = attachmentsDirectory
-        self.watchedAttachments = watchedAttachments
+        self.watchAttachments = watchAttachments
         self.localStorage = localStorage
         self.attachmentsQueueTableName = attachmentsQueueTableName
         self.errorHandler = errorHandler
@@ -128,6 +128,11 @@ public actor AttachmentQueue {
                 try await localStorage.makeDir(path: path)
             }
         }
+        
+        // Verify initial state
+        try await attachmentsService.withLock {context in
+            try await self.verifyAttachments(context: context)
+        }
 
         try await syncingService.startSync(period: syncInterval)
 
@@ -147,7 +152,7 @@ public actor AttachmentQueue {
 
                     // Add attachment watching task
                     group.addTask {
-                        for try await items in self.watchedAttachments {
+                        for try await items in try self.watchAttachments() {
                             try await self.processWatchedAttachments(items: items)
                         }
                     }
@@ -380,6 +385,31 @@ public actor AttachmentQueue {
             try await self.localStorage.rmDir(path: self.attachmentsDirectory)
         }
     }
+    
+    /// Verifies attachment records are present in the filesystem
+    private func verifyAttachments(context: AttachmentContext) async throws {
+        let attachments = try await context.getAttachments()
+        var updates: [Attachment] = []
+        
+        for attachment in attachments {
+            guard let localUri = attachment.localUri else {
+                continue
+            }
+            
+            let exists = try await localStorage.fileExists(filePath: localUri)
+            if attachment.state == AttachmentState.synced ||
+                attachment.state == AttachmentState.queuedUpload &&
+                !exists {
+                // The file must have been removed from the local storage
+                updates.append(attachment.with(
+                    state: .archived,
+                    localUri: .some(nil) // Clears the value
+                ))
+            }
+        }
+        
+        try await context.saveAttachments(attachments: updates)
+    }
 
     private func guardClosed() throws {
         if closed {

Sources/PowerSync/attachments/README.md

@@ -84,7 +84,7 @@ let queue = AttachmentQueue(
     db: db,
     attachmentsDirectory: try getAttachmentsDirectoryPath(),
     remoteStorage: RemoteStorage(),
-    watchedAttachments: try db.watch(
+    watchAttachments: { try db.watch(
         options: WatchOptions(
             sql: "SELECT photo_id FROM checklists WHERE photo_id IS NOT NULL",
             parameters: [],
@@ -95,13 +95,13 @@ let queue = AttachmentQueue(
                 )
             }
         )
-    )
+    ) }
 )
 ```
 
 - The `attachmentsDirectory` specifies where local attachment files should be stored. `FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first?.appendingPathComponent("attachments")` is a good choice.
 - The `remoteStorage` is responsible for connecting to the attachments backend. See the `RemoteStorageAdapter` protocol definition.
-- `watchedAttachments` is a publisher of `WatchedAttachmentItem`. These items represent the attachments that should be present in the application.
+- `watchAttachmens` is closure which generates a publisher of `WatchedAttachmentItem`. These items represent the attachments that should be present in the application.
 
 3. Call `startSync()` to start syncing attachments.