Better way to branch logics in the same response action of asynchronous task

[takehilo]

I want to separate logics when fetchData() is executed in actionA and when fetchData() is executed in actionB.

case .actionA:
    return .task {
        return .fetchResponse(await fetchData())
    }
case .actionB:
    return .task {
        return .fetchResponse(await fetchData())
    }
case let .fetchResponse(data):
    // if data from actionA
    // state.xxx = someLogicForA()

    // if data from actionB
    // state.xxx = someLogicForB()

I have come up with two methods, but I would like to know if there is a better way.

case .actionA:
    ...
    return .task {
        return .fetchResponseInActionA(await fetchData())
    }
case .actionB:
    ...
    return .task {
        return .fetchResponseInActionB(await fetchData())
    }
case let .fetchResponseInActionA(data):
    state.xxx = someLogicForA()
    return .none
case let .fetchResponseInActionB(data):
    state.xxx = someLogicForB()
    return .none

The other way:

enum FetchResponseType: Equatable {
    case inActionA
    case inActionB
}

enum Action: Equatable {
    case fetchResponse(SomeData, FetchResponseType)
}

case .actionA:
    ...
    return .task {
        return .fetchResponse(await fetchData(), .inActionA)
    }
case .actionB:
    ...
    return .task {
        return .fetchResponse(await fetchData(), .inActionB)
    }
case let .fetchResponse(data, .inActionA):
    state.xxx = someLogicForA()
    return .none
case let .fetchResponse(data, .inActionB):
    state.xxx = someLogicForB()
    return .none