Is it possible to check CoreData value before the app starts and show view based on the value in SwiftUI Project?

The app I am working has two view, Login View and Home View. When the app starts for the first time, it starts with the Login View. User have to register with name and id and click next button, which will navigate the user to the Home View. When the user register with the name and id the data get saved into the CoreData.
Once the user register, every next time user starts the app I want the app starts with the Home View.

import SwiftUI

@main
struct BJITXpressApp: App {
    let persistenceController = PersistenceController.shared

    var body: some Scene {
        WindowGroup {
            LoginView()
                .environment(\.managedObjectContext, persistenceController.container.viewContext)
        }
    }
}

At the starting of the app, the app will check for registration data from CoreData and if data is found the app will starts from Home View .

I have tried the following strategy on Login View .onAppear

struct LoginView: View {
    @Environment(\.managedObjectContext) var context
    @State private var name: String = ""
    @State private var employeeId: String = ""
    @State var isShowingHomeView = false
    
    var body: some View {
        NavigationView{...}
        .onAppear{
            checkFirstUse()
        }
        .fullScreenCover(isPresented: $isShowingHomeView){
            HomeView()
        }

But this way the app first starts with Login View and then if it found data in Coredata the navigate to the HomeView.
Instead of Starts -> LoginView -> Check CoreData -> Home View , I want it like Starts -> Check CoreData -> HomeView

Loading Core Data is both asynchronous and possibly error-producing. You must provide some UI for the period between when the UI shows and Core Data becomes available. You must not block the UI waiting for Core Data to complete loading. It can take arbitrarily long.

Your current approach is close: Starts -> LoginView -> Check CoreData -> Home View. But instead, what you need is Starts -> LoadingView -> Check CoreData -> HomeView|LoginView.

You need to create a new LoadingView. It could be blank. The more common thing to do is to show a progress indicator. But it has to be something because there is such a state, and you have to display something in every possible state.

In one of my projects, I use the following approach to a LoadingView:

struct LoadingView<Content: View, Model>: View {
    enum LoadState {
        case loading
        case loaded(Model)
        case error(Error)
    }

    @ViewBuilder let content: (Model) -> Content
    let loader: () async throws -> Model

    @State var loadState = LoadState.loading

    var body: some View {
        ZStack {
            Color.white
            switch loadState {
            case .loading: Text("Loading")
            case .loaded(let model): content(model)
            case .error(let error): Text(verbatim: "Error: \(error)")
            }
        }
        .task {
            do {
                loadState = .loaded(try await loader())
            } catch {
                loadState = .error(error)
            }
        }
    }
}

Where I have Text, you would probably want something more professional (this comes out of a personal hobby project).

In this project, I then have Views like:

struct DailyView: View {
    var body: some View {
        LoadingView() { model in
            LoadedDailyView(model: model)
        } loader: {
            try await DailyModel()
        }
    }
}

So the actual View always requires a Model, and it gets it as soon as the loader completes. This is far from the only approach. You can use something like you currently have. It's just an approach that I've used for inspiration.

Solved the issue by doing the folowing

enum LoginState {
    case isChecking
    case isLoggedIn
    case isNotLoggedIn
    case isWeekend
}

class ViewSelector: ObservableObject {
    @Published var loginState: LoginState = .isChecking
    
    init() {
        
        let isWeekend = isSundayOrMonday()
        if isWeekend{
            loginState = .isWeekend
        }else {
            let isLoggedIn =
            PersistenceController.shared.isRegisterDataAvailable()
            loginState = isLoggedIn ? .isLoggedIn : .isNotLoggedIn
        }
    } 

struct BJITXpressApp: App {
    let persistenceController = PersistenceController.shared
    
    @StateObject var viewModel = ViewSelector()

    var body: some Scene {
        WindowGroup {
            Group {
                if viewModel.loginState == .isChecking {
                    // Show a loading view or any other appropriate view while checking the login state
                    Text("Checking...")
                } else if viewModel.loginState == .isWeekend{
                    WeekendView()
                } else if viewModel.loginState == .isLoggedIn {
                    HomeView()
                        .environment(\.managedObjectContext, persistenceController.container.viewContext)
                } else if viewModel.loginState == .isNotLoggedIn {
                    LoginView()
                        .environment(\.managedObjectContext, persistenceController.container.viewContext)
                }
            }
        }
    }
}