Can I use the environment like this?

[ghost]

First of all, I apologize for not understanding enough.

Looking at the example code, I made this.
In particular, these changes were made to the environment, is this against your design principles?

import ComposableArchitecture

struct TodoListViewState: Equatable {
    var todos = [Todo]()
    var error: String?
    var isLoading = false
}

enum TodoListViewAction {
    case getTodos
    case updateTodos(TaskResult<[Todo]>)
}

struct TodoListViewEnvironment {
    var todoService: TodoServiceType
}

enum TodoError: Error {
    case someFail
}

let todoListReducer = Reducer<TodoListViewState, TodoListViewAction, TodoListViewEnvironment> { state, action, env in
    switch action {
    case .getTodos:
        state.isLoading = true
        return .task {
            do {
                let todos = try await env.todoService.getTodo()
                return .updateTodos(.success(todos))
            } catch {
                return .updateTodos(.failure(TodoError.someFail))
            }
        }
        
    case let .updateTodos(.success(todos)):
        state.todos = todos
        state.isLoading = false
        return .none
        
    case let .updateTodos(.failure(error)):
        state.error = error.localizedDescription
        state.isLoading = false
        return .none
    }
}

////////////////////////////////////////////////////////////////////////////

protocol TodoServiceType {
    func getTodo() async throws -> [Todo]
}

final class TodoService: TodoServiceType {
    static let shared = TodoService()
    
    private init() {}
    
    func getTodo() async throws -> [Todo] {
        guard let url = URL(string: "https://jsonplaceholder.typicode.com/todos") else { fatalError("url init fail") }
        
        let (data, _) = try await URLSession.shared.data(from: url)
        
        return try JSONDecoder().decode([Todo].self, from: data)
    }
}

Actually, I haven't tested for errors.
I wonder if it will work normally.
But the successful scenario works just fine.
But does this code against your design principles?

Thanks in advance for the reply.

[stephencelis]

@jay-linger What you have sketched out should work totally great, and you can provide a mock implementation of TodoServiceType for the purpose of testing.

In general, though, we feel that protocols are a bit of a heavy option for environment clients since you typically only have 2 conformances (a live conformance and a mockable one). Instead, we like using structs with endpoints, and then you can either return a live instance, or an instance that mocks each endpoint.

struct TodoService {
  var getTodos: () async throws -> [Todo]
}

extension TodoService {
  static let live = Self(
    getTodos: {
      let (data, _) = try await URLSession.shared
        .data(from: URL(string: "https://jsonplaceholder.typicode.com/todos")!)
        
      return try JSONDecoder().decode([Todo].self, from: data)
    }
  )
}

And then in tests you can instantiate a TodoService that returns some mock data or throws an error.

[ghost]

@stephencelis Thank you for reply.

Then, How about this?

// TodoSerive
struct TodoService {
    var getTodos: () async throws -> [Todo]
}

extension TodoService {
    static let live = Self(
        getTodos: {
            let (data, _) = try await URLSession.shared.data(from: URL(string: "https://jsonplaceholder.typicode.com/todos")!)
            return try JSONDecoder().decode([Todo].self, from: data)
        }
    )
    
    static let dev = Self(
        getTodos: {
            // return mock data or error
            throw TodoError.someFail
        }
    )
}

//////////////////////////////////////////////

struct TodoListViewEnvironment {
    var todoService: TodoService
} 

//////////////////////////////////////////////

@main
struct TodoListApp: App {
    
    private let todoListViewStore = Store(
        initialState: TodoListViewState(),
        reducer: todoListReducer,
        environment: TodoListViewEnvironment(
            todoService: .live // or .dev
        )
    )
    
    var body: some Scene {
        WindowGroup {
            TodoListView(store: todoListViewStore)
        }
    }
}