Added implementation to withUnsafeTransaction now that we have transactions to lean on

Author: dimitribouniol

Sources/CodableDatastore/Persistence/Disk Persistence/DiskPersistence.swift

@@ -23,6 +23,8 @@ public actor DiskPersistence<AccessMode: _AccessMode>: Persistence {
 
     var registeredDatastores: [String: [WeakDatastore]] = [:]
 
+    var lastTransaction: Transaction?
+    
     /// Initialize a ``DiskPersistence`` with a read-write URL.
     ///
     /// Use this initializer when creating a persistence from the main process that will access it, such as your app. To access the same persistence from another process, use ``init(readOnlyURL:)`` instead.
@@ -580,6 +582,23 @@ extension DiskPersistence {
     }
 }
 
+// MARK: - Transactions
+
+extension DiskPersistence {
+    public func withUnsafeTransaction(options: TransactionOptions, transaction: @escaping (_ persistence: DiskPersistence) async throws -> ()) async throws {
+        let (transacrion, task) = await Transaction.makeTransaction(persistence: self, lastTransaction: lastTransaction, options: options) {
+            try await transaction(self)
+        }
+        
+        /// Save the last non-concurrent transaction from the list. Note that disk persistence currently does not support concurrent idempotent transactions.
+        if !options.contains(.readOnly) {
+            lastTransaction = transacrion
+        }
+        
+        try await task.value
+    }
+}
+
 // MARK: - Helper Types
 
 class WeakDatastore {
@@ -638,8 +657,3 @@ private enum DiskPersistenceTaskLocals {
     static var storeInfo: StoreInfo?
 }
 
-extension DiskPersistence: _Persistence {
-    public func withUnsafeTransaction(options: TransactionOptions, transaction: @escaping (_ persistence: DiskPersistence) async throws -> ()) async throws {
-        
-    }
-}

Sources/CodableDatastore/Persistence/Disk Persistence/Transaction/Transaction.swift

@@ -16,14 +16,16 @@ extension DiskPersistence {
         var childTransactions: [Transaction] = []
 
         private(set) var task: Task<Void, Error>!
-        var options: TransactionOptions = []
+        let options: TransactionOptions
 
         private init(
             persistence: DiskPersistence,
-            parent: Transaction?
+            parent: Transaction?,
+            options: TransactionOptions
         ) {
             self.persistence = persistence
             self.parent = parent
+            self.options = options
         }
 
         private func attachTask<T>(
@@ -43,7 +45,6 @@ extension DiskPersistence {
                 return returnValue
             }
 
-            self.options = options
             self.task = Task {
                 _ = try await task.value
 
@@ -73,7 +74,8 @@ extension DiskPersistence {
 
             let transaction = Transaction(
                 persistence: persistence,
-                parent: nil
+                parent: nil,
+                options: options
             )
 
             let task = await transaction.attachTask(options: options) {
@@ -93,10 +95,12 @@ extension DiskPersistence {
         ) async -> (Transaction, Task<T, Error>) {
             let transaction = Transaction(
                 persistence: persistence,
-                parent: self
+                parent: self,
+                options: options
             )
 
-            let lastChild = childTransactions.last
+            /// Get the last non-concurrent transaction from the list. Note that disk persistence currently does not support concurrent idempotent transactions.
+            let lastChild = childTransactions.last { !$0.options.contains(.readOnly) }
             childTransactions.append(transaction)
 
             let task = await transaction.attachTask(options: options) {