Невозможно вызвать изменяющую асинхронную функцию create для изолированного от актера свойства dataService

Result в основном используется для обработчиков завершения. Поскольку у вас нет обработчиков завершения, лучше использовать функции бросания. И я исправил Cannot call mutating async function 'create' on actor-isolated property 'dataService', сделав их классом. Потому что занятия для этого более подходят. И вы можете делать инъекции зависимостей (у вас есть для этого почти идеальная настройка). И оповещение работает.

import SwiftUI

struct Item: Hashable, Sendable {
    var name: String
}

class MockDb {
    private var items: [Item] = []
    
    func readItems() async throws -> [Item] {
        try? await Task.sleep(nanoseconds: 1_000_000_000)
        throw AdapterError.dataError
    }
    func createItem(_ item: Item) async throws -> Bool {
        items.append(item)
        return true
    }
}

enum AdapterError: Error {
    case dataError
}
extension AdapterError: LocalizedError {
    var errorDescription: String? {
        switch self {
        case .dataError: return "Data error accrued"
        }
    }
}

class ItemDataAdapter: IDataService {
    var mock: MockDb
    
    init(mock: MockDb) {
        self.mock = mock
    }
    
    func read() async throws -> [Item] {
        try await mock.readItems()
    }
    func create(_ item: Item) async throws -> Bool {
        try await mock.createItem(item)
    }
}

class ItemDataService: IDataService {
    var dataAdapter: IDataService
    
    init(dataAdapter: IDataService) {
        self.dataAdapter = dataAdapter
    }
    
    func read() async throws -> [Item] {
        try await dataAdapter.read()
    }
    func create(_ item: Item) async throws -> Bool {
        try await dataAdapter.create(item)
    }
}

protocol IDataService {
    func read() async throws -> [Item]
    mutating func create(_ item: Item) async throws -> Bool
}

//Domain
@MainActor
class ItemDomainStore: ObservableObject {
    @Published var isAlertShowing = false
    @Published var items: [Item] = []
    @Published var error: AdapterError?
    
    var dataService: ItemDataService
    
    init(dataService: IDataService) {
        self.dataService = ItemDataService(dataAdapter: dataService)
    }
    
    @Sendable func read() async {
        do {
            let result = try await dataService.read()
            
            await MainActor.run {
                items = result
            }
        } catch let error {
            await MainActor.run {
                self.error = (error as! AdapterError)
                self.isAlertShowing = true
            }
        }
    }
    
    @Sendable func create(_ item: Item) async {
        do {
            let result = try await dataService.create(item)
            
            await MainActor.run {
                // Do some things
            }
        } catch {
            // Do some things
        }
    }
}

//Presentation
struct ItemListScreen: View {
    @EnvironmentObject private var domainStore: ItemDomainStore
    
    var body: some View {
        VStack {
            List(domainStore.items, id: \.self) { item in
                Text(item.name)
            }
            Button("create item") {
                Task {
                    await domainStore.create(Item(name: "Marry"))
                }
            }
            .alert(isPresented: $domainStore.isAlertShowing, error: domainStore.error) { _ in
                Button("Ok") {}
            } message: { error in
                Text("Please try again later.")
            }

        }
        .task {
            await domainStore.read()
        }
    }
}

//main screen.
struct ContentView: View {
    let mock = MockDb()
    
    var body: some View {
        ItemListScreen()
            .environmentObject(ItemDomainStore(dataService: ItemDataService(dataAdapter: ItemDataAdapter(mock: mock))))
    }
}

Вы должны убедиться, что ваши сервисы Sendable, если вы хотите иметь возможность их изменять.

struct автоматически согласовывается, поэтому вы можете просто добавить наследование.

protocol IDataService: Sendable {
    func read() async -> Result<[Item], AdapterError>
    mutating func create(_ item: Item) async -> Result<Bool, AdapterError>
}