Merge pull request #17 from sideeffect-io/feature/improve-search-apis

samples: improve SearchApis

Author: twittemb

Samples/SearchApis/SearchApis/Feature/SideEffect/Search.swift

@@ -5,11 +5,17 @@
 //  Created by Thibault Wittemberg on 21/08/2022.
 //
 
-@Sendable func search(query: String, searchFunction: (String) async throws -> [Entry]) async -> Event {
+@Sendable func search(
+  query: String,
+  searchFunction: (String) async throws -> [Entry]
+) async -> Event? {
   do {
     let entries = try await searchFunction(query)
     return Event.searchHasSucceeded(entries: entries)
-  } catch {
+  } catch is CancellationError {
     return Event.searchHasFailed
+  } catch {
+    logger.debug("Search with query \(query) was cancelled")
+    return nil
   }
 }

Samples/SearchApis/SearchApis/Feature/StateMachine/Event.swift

@@ -8,7 +8,8 @@
 import AsyncStateMachine
 
 enum Event: DSLCompatible, Equatable {
-case searchIsRequested(query: String)
-case searchHasSucceeded(entries: [Entry])
-case searchHasFailed
+  case searchIsRequested(query: String)
+  case searchHasSucceeded(entries: [Entry])
+  case searchHasFailed
+  case refreshIsRequested
 }

Samples/SearchApis/SearchApis/Feature/StateMachine/Output.swift

@@ -8,5 +8,5 @@
 import AsyncStateMachine
 
 enum Output: DSLCompatible, Equatable {
-case search(query: String)
+  case search(query: String)
 }

Samples/SearchApis/SearchApis/Feature/StateMachine/State.swift

@@ -8,18 +8,23 @@
 import AsyncStateMachine
 
 enum State: DSLCompatible, Equatable {
-case idle
-case searching(query: String)
-case loaded(query: String, entries: [Entry])
-case failed
+  case idle
+  case searching(context: Context)
+  case loaded(context: Context)
+  case failed
+
+  struct Context: Equatable {
+    let query: String
+    var entries: [Entry] = []
+  }
 }
 
 extension State: CustomStringConvertible {
   var description: String {
     switch self {
       case .idle: return "idle"
-      case .searching(let query): return "search with the query \(query)"
-      case .loaded(_, let entries): return "loaded with \(entries.count) entries"
+      case .searching(let context): return "search with the query \(context.query), previous \(context.entries.count) entries"
+      case .loaded(let context): return "loaded with the query \(context.query), previous \(context.entries.count) entries"
       case .failed: return "failed"
     }
   }

Samples/SearchApis/SearchApis/Feature/StateMachine/StateMachine.swift

@@ -11,28 +11,42 @@ func stateMachine(initial: State) -> StateMachine<State, Event, Output> {
   StateMachine(initial: .idle) {
     When(states: OneOf{
       State.idle
-      State.loaded(query:entries:)
+      State.loaded(context:)
       State.failed
     }) { _ in
       Execute.noOutput
     } transitions: { _ in
       On(event: Event.searchIsRequested(query:)) { query in
         Guard(predicate: !query.isEmpty)
       } transition: { query in
-        Transition(to: State.searching(query: query))
+        Transition(to: State.searching(context: State.Context(query: query)))
       }
     }
 
-    When(state: State.searching(query:)) { query in
-      Execute(output: Output.search(query: query))
-    } transitions: { query in
+    When(state: State.searching(context:)) { context in
+      Execute(output: Output.search(query: context.query))
+    } transitions: { context in
       On(event: Event.searchHasSucceeded(entries:)) { entries in
-        Transition(to: State.loaded(query: query, entries: entries))
+        Transition(to: State.loaded(context: State.Context(query: context.query, entries: entries)))
       }
 
       On(event: Event.searchHasFailed) { _ in
         Transition(to: State.failed)
       }
+
+      On(event: Event.searchIsRequested(query:)) { query in
+        Guard(predicate: !query.isEmpty)
+      } transition: { query in
+        Transition(to: State.searching(context: State.Context(query: query, entries: context.entries)))
+      }
+    }
+
+    When(state: State.loaded(context:)) { _ in
+      Execute.noOutput
+    } transitions: { context in
+      On(event: Event.refreshIsRequested) { _ in
+        Transition(to: State.searching(context: context))
+      }
     }
   }
 }

Samples/SearchApis/SearchApis/Feature/View/RootView.swift

@@ -17,6 +17,12 @@ struct RootView: View {
         List(self.stateMachine.state.entries) { entry in
           Text("\(entry.api) (\(entry.link))")
         }
+        .refreshable {
+          await self.stateMachine.send(
+            Event.refreshIsRequested,
+            resumeWhen: State.loaded(context:)
+          )
+        }
 
         if self.stateMachine.state.isSearching {
           ProgressView()
@@ -59,10 +65,18 @@ struct RootView_Previews: PreviewProvider {
 
   static var previews: some View {
     Group {
-      RootView(stateMachine: mockViewStateMachine(initial: .idle))
-      RootView(stateMachine: mockViewStateMachine(initial: .searching(query: "mar")))
-      RootView(stateMachine: mockViewStateMachine(initial: .loaded(query: "mar", entries: mockEntries)))
-      RootView(stateMachine: mockViewStateMachine(initial: .failed))
+      RootView(
+        stateMachine: mockViewStateMachine(initial: .idle)
+      )
+      RootView(
+        stateMachine: mockViewStateMachine(initial: .searching(context: State.Context(query: "Mar")))
+      )
+      RootView(
+        stateMachine: mockViewStateMachine(initial: .loaded(context: State.Context(query: "mar", entries: mockEntries)))
+      )
+      RootView(
+        stateMachine: mockViewStateMachine(initial: .failed)
+      )
     }
   }
 }

Samples/SearchApis/SearchApis/Feature/View/State+ViewState.swift

@@ -10,20 +10,20 @@ import SwiftUI
 extension State {
   var query: String {
     switch self {
-      case .searching(let query), .loaded(let query, _): return query
+      case .searching(let context), .loaded(let context): return context.query
       default: return ""
     }
   }
 
   var entries: [Entry] {
     switch self {
-      case .loaded(_, let entries): return entries
+      case .searching(let context), .loaded(let context): return context.entries
       default: return []
     }
   }
 
   var isSearching: Bool {
-    if case .searching = self {
+    if case .searching(let context) = self, context.entries.isEmpty {
       return true
     }
     return false

Samples/SearchApis/SearchApis/Implementation/SearchFromRestApi.swift

@@ -11,13 +11,13 @@ import Foundation
   guard let url = URL(string: "https://api.publicapis.org/entries?title=\(query)") else {
     throw NSError(domain: "network", code: 1)
   }
-
+  
   let (data, response) = try await URLSession.shared.data(from: url)
-
+  
   guard let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode == 200 else {
     throw NSError(domain: "network", code: 2)
   }
-
+  
   let result = try JSONDecoder().decode(Response.self, from: data)
   return result.entries
 }

Samples/SearchApis/SearchApis/SearchApisApp.swift

@@ -13,7 +13,7 @@ var viewStateMachine: RawViewStateMachine<State, Event, Output> {
 
   let stateMachine = stateMachine(initial: .idle)
   let runtime = Runtime<State, Event, Output>()
-    .map(output: Output.search(query:), to: searchSideEffect)
+    .map(output: Output.search(query:), to: searchSideEffect, priority: .low, strategy: .cancel(when: State.searching(context:)))
     .register(middleware: logToOSLog(state:))
 
   let asyncStateMachine = AsyncStateMachine(stateMachine: stateMachine, runtime: runtime)