code cleanup. Update archiving logid

Author: stevensJourney

Sources/PowerSync/attachments/Attachment.swift

@@ -48,7 +48,7 @@ public struct Attachment {
 
     /// Specifies if the attachment has been synced locally before.
     /// This is particularly useful for restoring archived attachments in edge cases.
-    public let hasSynced: Int?
+    public let hasSynced: Bool?
 
     /// Extra attachment metadata
     public let metaData: String?
@@ -59,7 +59,7 @@ public struct Attachment {
         filename: String,
         state: AttachmentState,
         timestamp: Int = 0,
-        hasSynced: Int? = 0,
+        hasSynced: Bool? = false,
         localUri: String? = nil,
         mediaType: String? = nil,
         size: Int64? = nil,
@@ -89,27 +89,40 @@ public struct Attachment {
     ///   - metaData: Optional new metadata.
     /// - Returns: A new `Attachment` with updated values.
     func with(
-        filename _: String? = nil,
+        filename: String? = nil,
         state: AttachmentState? = nil,
-        timestamp _: Int = 0,
-        hasSynced: Int?? = 0,
+        timestamp : Int = 0,
+        hasSynced: Bool? = nil,
         localUri: String?? = .none,
         mediaType: String?? = .none,
         size: Int64?? = .none,
         metaData: String?? = .none
     ) -> Attachment {
         return Attachment(
             id: id,
-            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
+            filename: filename ?? self.filename,
+            state: state ?? self.state,
+            timestamp: timestamp > 0 ? timestamp : self.timestamp,
+            hasSynced: hasSynced ?? self.hasSynced,
+            localUri: resolveOverride(localUri, current: self.localUri),
+            mediaType: resolveOverride(mediaType, current: self.mediaType),
+            size: resolveOverride(size, current: self.size),
+            metaData: resolveOverride(metaData, current: self.metaData)
         )
     }
+    
+    /// Resolves double optionals
+    /// if a non nil value is provided: the override will be used
+    /// if .some(nil) is provided: The value will be set to nil
+    /// // if nil is provided:  the current value will be preserved
+    private func resolveOverride<T>(_ override: T??, current: T?) -> T? {
+        if let value = override {
+            return value  // could be nil (explicit clear) or a value
+        } else {
+            return current  // not provided, use current
+        }
+    }
+
 
     /// Constructs an `Attachment` from a `SqlCursor`.
     ///
@@ -122,7 +135,7 @@ public struct Attachment {
             filename: cursor.getString(name: "filename"),
             state: AttachmentState.from(cursor.getLong(name: "state")),
             timestamp: cursor.getLong(name: "timestamp"),
-            hasSynced: cursor.getLongOptional(name: "has_synced"),
+            hasSynced: cursor.getLong(name: "has_synced") > 0,
             localUri: cursor.getStringOptional(name: "local_uri"),
             mediaType: cursor.getStringOptional(name: "media_type"),
             size: cursor.getLongOptional(name: "size")?.int64Value,

Sources/PowerSync/attachments/AttachmentQueue.swift

@@ -229,16 +229,14 @@ public class AttachmentQueue {
             var attachmentUpdates = [Attachment]()
 
             for item in items {
-                let existingQueueItem = currentAttachments.first { $0.id == item.id }
-
-                if existingQueueItem == nil {
+                guard let existingQueueItem = currentAttachments.first(where: { $0.id == item.id }) else {
+                    // Item is not present in the queue
+                    
                     if !self.downloadAttachments {
                         continue
                     }
+
                     // This item should be added to the queue
-                    // This item is assumed to be coming from an upstream sync
-                    // Locally created new items should be persisted using saveFile before
-                    // this point.
                     let filename = self.resolveNewAttachmentFilename(
                         attachmentId: item.id,
                         fileExtension: item.fileExtension
@@ -248,43 +246,53 @@ public class AttachmentQueue {
                         Attachment(
                             id: item.id,
                             filename: filename,
-                            state: AttachmentState.queuedDownload
+                            state: .queuedDownload,
+                            hasSynced: false
                         )
                     )
-                } else if existingQueueItem!.state == AttachmentState.archived {
+                    continue
+                }
+
+                if existingQueueItem.state == AttachmentState.archived {
                     // The attachment is present again. Need to queue it for sync.
                     // We might be able to optimize this in future
-                    if existingQueueItem!.hasSynced == 1 {
+                    if existingQueueItem.hasSynced == true {
                         // No remote action required, we can restore the record (avoids deletion)
                         attachmentUpdates.append(
-                            existingQueueItem!.with(state: AttachmentState.synced)
+                            existingQueueItem.with(state: AttachmentState.synced)
                         )
                     } else {
                         // The localURI should be set if the record was meant to be downloaded
                         // and has been synced. If it's missing and hasSynced is false then
                         // it must be an upload operation
-                        let newState = existingQueueItem!.localUri == nil ?
+                        let newState = existingQueueItem.localUri == nil ?
                             AttachmentState.queuedDownload :
                             AttachmentState.queuedUpload
 
                         attachmentUpdates.append(
-                            existingQueueItem!.with(state: newState)
+                            existingQueueItem.with(state: newState)
                         )
                     }
                 }
             }
 
-            /**
-             * Archive any items not specified in the watched items except for items pending delete.
-             */
             for attachment in currentAttachments {
-                if attachment.state != AttachmentState.queuedDelete &&
-                    attachment.state != AttachmentState.queuedUpload,
-                    items.first(where: { $0.id == attachment.id }) == nil
-                {
-                    attachmentUpdates.append(
-                        attachment.with(state: AttachmentState.archived)
-                    )
+                let notInWatchedItems = items.first(where: { $0.id == attachment.id }) == nil
+                if notInWatchedItems {
+                    switch attachment.state {
+                    case .queuedDelete, .queuedUpload:
+                        // Only archive if it has synced
+                        if attachment.hasSynced == true {
+                            attachmentUpdates.append(
+                                attachment.with(state: .archived)
+                            )
+                        }
+                    default:
+                        // Archive other states such as QUEUED_DOWNLOAD
+                        attachmentUpdates.append(
+                            attachment.with(state: .archived)
+                        )
+                    }
                 }
             }
 

Sources/PowerSync/attachments/SyncingService.swift

@@ -231,7 +231,7 @@ public class SyncingService {
             let fileData = try await localStorage.readFile(filePath: localUri)
             try await remoteStorage.uploadFile(fileData: fileData, attachment: attachment)
 
-            return attachment.with(state: AttachmentState.synced, hasSynced: 1)
+            return attachment.with(state: AttachmentState.synced, hasSynced: true)
         } catch {
             if let errorHandler = errorHandler {
                 let shouldRetry = await errorHandler.onUploadError(attachment: attachment, error: error)
@@ -256,7 +256,7 @@ public class SyncingService {
 
             return attachment.with(
                 state: AttachmentState.synced,
-                hasSynced: 1,
+                hasSynced: true,
                 localUri: attachmentPath
             )
         } catch {