fix: Further changes to fix queueing

Signed-off-by: Fabrizio Demaria <fabrizio.f.demaria@gmail.com>

Author: fabriziodemaria

Sources/OpenFeature/AsyncCoalescingSerialQueue.swift

@@ -0,0 +1,81 @@
+import Foundation
+
+/// Unified serial async task queue with operation-type-aware coalescing.
+/// - Non-coalescable operations always execute in order
+/// - Consecutive coalescable operations are coalesced (only the last one executes)
+/// - Order is always preserved
+internal actor AsyncUnifiedQueue {
+    private var currentTask: Task<Void, Never>?
+
+    private struct QueuedOperation {
+        let operation: () async -> Void
+        let continuation: CheckedContinuation<Void, Never>
+        let canCoalesce: Bool
+    }
+
+    private var queue: [QueuedOperation] = []
+
+    /// Runs the given operation serially.
+    /// - If canCoalesce is false: operation always executes
+    /// - If canCoalesce is true: may be skipped if superseded by a later coalescable operation
+    func run(canCoalesce: Bool, operation: @Sendable @escaping () async -> Void) async {
+        await withCheckedContinuation { continuation in
+            queue.append(QueuedOperation(operation: operation, continuation: continuation, canCoalesce: canCoalesce))
+
+            if currentTask == nil {
+                processNext()
+            }
+        }
+    }
+
+    private func processNext() {
+        guard !queue.isEmpty else {
+            currentTask = nil
+            return
+        }
+
+        // Find the next batch to execute
+        // A batch is either:
+        // 1. A single non-coalescable operation, OR
+        // 2. Consecutive coalescable operations (we execute only the last one)
+
+        let firstOp = queue[0]
+
+        if !firstOp.canCoalesce {
+            // Non-coalescable operation: execute it immediately
+            let op = queue.removeFirst()
+            currentTask = Task { [weak self] in
+                await op.operation()
+                op.continuation.resume()
+                await self?.processNext()
+            }
+        } else {
+            // Coalescable operation: find all consecutive coalescable ops
+            var coalescableCount = 0
+            for op in queue {
+                if op.canCoalesce {
+                    coalescableCount += 1
+                } else {
+                    break
+                }
+            }
+
+            // Execute only the last one in the coalescable batch
+            let toSkip = Array(queue.prefix(coalescableCount - 1))
+            let toExecute = queue[coalescableCount - 1]
+            queue.removeFirst(coalescableCount)
+
+            currentTask = Task { [weak self] in
+                await toExecute.operation()
+
+                // Resume all continuations (both skipped and executed)
+                for op in toSkip {
+                    op.continuation.resume()
+                }
+                toExecute.continuation.resume()
+
+                await self?.processNext()
+            }
+        }
+    }
+}

Sources/OpenFeature/AsyncSerialQueue.swift

@@ -6,8 +6,7 @@ import Foundation
 public class OpenFeatureAPI {
     private let eventHandler = EventHandler()
     private let stateQueue = DispatchQueue(label: "com.openfeature.state.queue") // Sync queue to change state atomically
-    private let providerQueue: AsyncSerialQueue  // Non-coalescing queue for provider operations
-    private let contextQueue: AsyncCoalescingSerialQueue  // Coalescing queue for context updates
+    private let unifiedQueue: AsyncUnifiedQueue  // Unified queue for all operations with smart coalescing
 
     private(set) var providerSubject = CurrentValueSubject<FeatureProvider?, Never>(nil)
     private(set) var evaluationContext: EvaluationContext?
@@ -18,8 +17,7 @@ public class OpenFeatureAPI {
     static public let shared = OpenFeatureAPI()
 
     public init() {
-        providerQueue = AsyncSerialQueue()
-        contextQueue = AsyncCoalescingSerialQueue()
+        unifiedQueue = AsyncUnifiedQueue()
     }
 
     /**
@@ -64,7 +62,7 @@ public class OpenFeatureAPI {
 
     public func clearProvider() {
         Task {
-            await providerQueue.run { [self] in
+            await unifiedQueue.run(canCoalesce: false) { [self] in
                 stateQueue.sync {
                     self.providerSubject.send(nil)
                     self.providerStatus = .notReady
@@ -158,7 +156,7 @@ public class OpenFeatureAPI {
     }
 
     private func setProviderInternal(provider: FeatureProvider, initialContext: EvaluationContext? = nil) async {
-        await providerQueue.run { [self] in
+        await unifiedQueue.run(canCoalesce: false) { [self] in
             // Set initial state atomically
             stateQueue.sync {
                 self.providerStatus = .notReady
@@ -195,7 +193,7 @@ public class OpenFeatureAPI {
     }
 
     private func updateContext(evaluationContext: EvaluationContext) async {
-        await contextQueue.run { [self] in
+        await unifiedQueue.run(canCoalesce: true) { [self] in
             // Get old context and set new context atomically
             let (oldContext, provider) = stateQueue.sync { () -> (EvaluationContext?, FeatureProvider?) in
                 let oldContext = self.evaluationContext