Send multiple time action

[saroar]

https://www.veed.io/view/34dd797e-055b-46f5-8eee-78ff5ad01474/showcase?sharingWidget=true

AuthenticationView.zip

case let .sendPhoneNumberButtonTapped(phoneNumber):
          state.isLoginRequestInFlight = true

          do {
            let phoneNumberKit = PhoneNumberKit()
            let parseNumber = try phoneNumberKit.parse(phoneNumber)
            let e164PhoneNumber = phoneNumberKit.format(parseNumber, toType: .e164)
            state.authResponse.phoneNumber = e164PhoneNumber
          } catch {
            print(#line, error.localizedDescription)
            return .none
          }

            return .task {  [authResponse = state.authResponse] in
              return .loninResponse(
                  await TaskResult {
                      try await authClient.login(authResponse)
                  }
              )
            }
``` this code run 2 time on send http request 

Xcode `Version 14.0.1 (14A400)`
TCA Version: 0.42.0

[saroar]

I create new app and try what I send here all work good so very strange why app is sending two times :(

[saroar]

any help will appreciated if you can check this my code

//
//  AppFeature.swift
//  
//
//  Created by Saroar Khandoker on 22.11.2021.
//

import SwiftUI

import ComposableArchitecture
import ComposableUserNotifications
import ComposableStoreKit
import NWSharedModels
import TCAHelpers

import WordClient
import UserDefaultsClient
import AuthClient
import AuthClientLive

import KeychainService

import WordFeature
import DayWordCardsFeature
import AuthenticationView
import WelcomeFeature

public struct AppReducer: ReducerProtocol {
    public struct State: Equatable {
        public var login: Login.State?
        public var welcome: Welcome.State?
        public var word: WordReducer.State

        public init(
            login: Login.State? = nil,
            welcome: Welcome.State? = nil,
            word: WordReducer.State = .init()
        ) {
            self.login = login
            self.welcome = welcome
            self.word = word
        }

        public var currentLogin: Login.State {
            get {
                Login.State()
            }
            set {
                let oldValue = self
                let isValidationCodeIsSend = newValue.isValidationCodeIsSend ==
                    .some(true) || oldValue.login?.isValidationCodeIsSend == .some(true)
                let status = oldValue.login?.authResponse
                self.login = newValue
                self.login?.isValidationCodeIsSend = isValidationCodeIsSend
                self.login?.authResponse = status ?? .init(phoneNumber: "")
            }
        }

        public var currentWelcome: Welcome.State {
            get {
                Welcome.State()
            }
            set {
                let oldValue = self
                let name = oldValue.welcome?.name
                let isNameValid = newValue.isNameValid == .some(true) || oldValue.welcome?.isNameValid == .some(true)
                let currentLang = oldValue.welcome?.currentLngCode
                let learningLang = oldValue.welcome?.learnLangCode
                let selectedPage = oldValue.welcome?.selectedPage
                let startHour = oldValue.welcome?.startHour
                let endHour = oldValue.welcome?.endHour

                self.welcome = newValue
                self.welcome?.name = name ?? ""
                self.welcome?.currentLngCode = currentLang ?? .bangla
                self.welcome?.learnLangCode = learningLang  ?? .english
                self.welcome?.isNameValid = isNameValid
                self.welcome?.selectedPage = selectedPage ?? .schaduleForm
                self.welcome?.startHour = startHour ?? Date()
                self.welcome?.endHour = endHour ?? Date()
            }
        }
    }

    public enum Action {
        case onAppear
        case welcome(Welcome.Action)
        case word(WordReducer.Action)
        case login(Login.Action)
        case appDelegate(AppDelegateReducer.Action)
        case didChangeScenePhase(ScenePhase)

        case paymentTransaction(StoreKitClient.PaymentTransactionObserverEvent)
        case verifyReceiptResponse(TaskResult<ReceiptFinalizationEnvelope>)
    }

    @Dependency(\.userDefaults) var userDefaults
    @Dependency(\.userNotifications) var userNotifications

    public init() {}

    public var body: some ReducerProtocol<State, Action> {
        self.core
            .ifLet(\.login, action: /Action.login) {
                Login()
            }
            .ifLet(\.welcome, action: /Action.welcome) {
                Welcome()
            }


        StoreKitLogic()
    }

    @ReducerBuilder<State, Action>
    var core: some ReducerProtocol<State, Action> {
        Scope(state: \.word.settingsState.userSettings, action: /Action.appDelegate) {
            AppDelegateReducer()
        }

        Scope(state: \.currentLogin, action: /Action.login) {
            Login()
        }

        Scope(state: \.currentWelcome, action: /Action.welcome) {
            Welcome()
        }

        Scope(state: \.word, action: /Action.word) {
            WordReducer()
        }

        Reduce { state, action in
            switch action {

            case .onAppear:
                let isFormFillUpCompleted = userDefaults
                    .boolForKey(AppUserDefaults.Key.isFormFillUpCompleted.rawValue) == true

                let isAuthorized = userDefaults.boolForKey(AppUserDefaults.Key.isAuthorized.rawValue) == true

                if isFormFillUpCompleted && isAuthorized {

                    state.login = nil
                    state.welcome = nil
                    state.word = .init(dayWordCardState: DayWordCardsState.init())
                    return .none

                } else if !isAuthorized {
                    state.login = .init()
                    return .none

                } else {
                    state.welcome = .init()
                    return .none
                }

            case .welcome(.moveToWordView):
                state.welcome = nil
                state.word = .init()
                return .fireAndForget {
                   await userDefaults.setBool(
                        true,
                        UserDefaultKeys.isFormFillUpCompleted.rawValue
                   )
                }

            case .welcome:
                state.login = nil
                return .none

            case .word:
                return .none

            case .login(.verificationResponse(.success(_))):
                state.login = nil
                state.welcome = .init()
                return .none

            case .login:
                return .none

            case let .appDelegate(.userNotifications(.didReceiveResponse(_, completionHandler))):
              return .fireAndForget { completionHandler() }
            case .appDelegate:
                return .none

            case .didChangeScenePhase(_):
                return .none
            case .paymentTransaction(_):
                return .none
            case .verifyReceiptResponse(_):
                return .none
            }
        }
    }
}

[saroar]

for now it fixed remove duplication Scope