LiveQuery is never subscribing

[davidhakki]

Hey @cbaker6 I switched over to this version of Parse-Swift and everything has been great except LiveQuery

So to prevent me from having to deal with an async view init I am doing this

@StateObject private var subscription: Subscription<Patient> = .init(query: Query<Patient>())

Then on launch of the view I am doing this

   .task {
            do {
                try await updateQuery()
            } catch {
                errorMsg = error.localizedDescription
            }
            
            if userService.profile == nil {
                try? await userService.loadProfile()
            }
        }
        
    }
    
    func updateQuery() async throws {
        let containedQuery = Patient.query(containedIn(key: "providers", array: [facilityService.currentFacilityId]))
        self.subscription.query = containedQuery
        _ = try await self.subscription.query.subscribe()
        patientService.patients = try await subscription.query.findAll()
    }

But under no circumstances is this every changing from "Not subscribed to query"

        if subscription.isSubscribed {
               Text("Subscribed to query!")
           } else if subscription.isUnsubscribed {
               Text("Unsubscribed from query!")
           } else if let event = subscription.event {

               //: This is how you register to receive notifications of events related to your LiveQuery.
               switch event.event {

               case .entered(let object):
                   Text("Entered with points: \(String(describing: object.id))")
               case .left(let object):
                   Text("Left with points: \(String(describing: object.id))")
               case .created(let object):
                   Text("Created with points: \(String(describing: object.id))")
               case .updated(let object):
                   Text("Updated with points: \(String(describing: object.id))")
               case .deleted(let object):
                   Text("Deleted with points: \(String(describing: object.id))")
               }
           } else {
               Text("Not subscribed to a query")
           }

What am I doing wrong? The server is setup correctly to have it enabled and the Patient object is listed in the array for livequery.

Information:
Server: Parse Server 6.2.0
SDK: 5.12.3
Xcode: 26
Building for: macOS 26, iOS 26, iPadOS 26, VisionOS 26

[davidhakki]

The .findAll is loading everything fine as well so I don't think it is the query

[cbaker6]

Did you compare your code to the playground examples? Also, you can test the playgrounds (and your code) with a known working server config (https://github.com/netreconlab/Parse-Swift?tab=readme-ov-file#test-drive-parse-swift). After you confirm that works, you can change the settings in the playground files and see if they work with your server. If the playgrounds work, you are doing something incorrectly in your code. Working examples are below:

• Old style callbacks

• Using LiveQuery with SwiftUI views

You can also look at this thread along with others: https://community.parseplatform.org/t/livequery-stops-and-does-not-restart-in-the-background/2410

[davidhakki]

Hey @cbaker6. I confirmed with 100% certainty the server is working fine, I am able to livequery without issue using the older version of Parse Swift, The problem with the SwiftUI example is that you are doing this:

@MainActor
func startView() async throws {
    let subscribe = try await query.subscribe()
    PlaygroundPage.current.setLiveView(ContentView(subscription: subscribe))
}

But I am trying to setup the query etc after the view is loaded. This worked fine on the 4.14 version of ParseSwift but for the life of me I cannot get it to work on version 5

My implementation of the 'new way':

import SwiftUI
import ParseSwift

//: Create a query just as you normally would.
var query = GameScore.query()

//: To use subscriptions inside of SwiftUI
struct ContentView: View {

    //: A LiveQuery subscription can be used as a view model in SwiftUI
    @StateObject var subscription: Subscription<GameScore> = .init(query: GameScore.query())
    @Environment(\.scenePhase) var scenePhase

    var body: some View {
        VStack {

            if subscription.subscribed != nil {
                Text("Subscribed to query!")
            } else if subscription.unsubscribed != nil {
                Text("Unsubscribed from query!")
            } else if let event = subscription.event {

                //: This is how you register to receive notifications of events related to your LiveQuery.
                switch event.event {

                case .entered(let object):
                    Text("Entered with points: \(String(describing: object.points))")
                case .left(let object):
                    Text("Left with points: \(String(describing: object.points))")
                case .created(let object):
                    Text("Created with points: \(String(describing: object.points))")
                case .updated(let object):
                    Text("Updated with points: \(String(describing: object.points))")
                case .deleted(let object):
                    Text("Deleted with points: \(String(describing: object.points))")
                }
            } else {
                Text("Not subscribed to a query")
            }

            Text("Update GameScore in Parse Dashboard to see changes here:")

            Button(action: {
                Task {
                    try? await subscription.query.unsubscribe()
                }
            }, label: {
                Text("Unsubscribe")
                    .font(.headline)
                    .background(Color.red)
                    .foregroundColor(.white)
                    .padding()
                    .cornerRadius(20.0)
            })
            Spacer()
                .task {
                    do {
                        let subscribe = try await query.subscribe()
                    } catch {
                        print(error.localizedDescription)
                    }
                }
                .onChange(of: scenePhase, perform: { newPhase in
                    if newPhase == .background {
                        print("in background")
                    } else {
                       
                     //   print(test?.results)
                    }
                    
                
                })
                
                
            
        }
    }
}

How it was done (and works fine) on the 'old way':

struct ContentView: View {

    //: A LiveQuery subscription can be used as a view model in SwiftUI
    @ObservedObject var subscription = query.subscribe!
    @Environment(\.scenePhase) var scenePhase

    var body: some View {
        VStack {

            if subscription.subscribed != nil {
                Text("Subscribed to query!")
            } else if subscription.unsubscribed != nil {
                Text("Unsubscribed from query!")
            } else if let event = subscription.event {

                //: This is how you register to receive notifications of events related to your LiveQuery.
                switch event.event {

                case .entered(let object):
                    Text("Entered with points: \(String(describing: object.points))")
                case .left(let object):
                    Text("Left with points: \(String(describing: object.points))")
                case .created(let object):
                    Text("Created with points: \(String(describing: object.points))")
                case .updated(let object):
                    Text("Updated with points: \(String(describing: object.points))")
                case .deleted(let object):
                    Text("Deleted with points: \(String(describing: object.points))")
                }
            } else {
                Text("Not subscribed to a query")
            }

            Text("Update GameScore in Parse Dashboard to see changes here:")

            Button(action: {
                try? query.unsubscribe()
            }, label: {
                Text("Unsubscribe")
                    .font(.headline)
                    .background(Color.red)
                    .foregroundColor(.white)
                    .padding()
                    .cornerRadius(20.0)
            })
            Spacer()
                .onChange(of: scenePhase, perform: { newPhase in
                    if newPhase == .background {
                        print("in background")
                    } else {
                        query.subscribe!
                     //   print(test?.results)
                    }
                    
                
                })
                
                
            
        }
    }
}

[cbaker6]

I suspect you either have something configured incorrectly on your server or your client as I've tested again on Parse Server 8.2.4 and Parse-Swift 5.12.3. Mind you, there are several unit tests that have been in place for years, which should detect if LiveQuery breaks, so I doubt there's an issue with ParseSwift itself.

Did you test using the Playgrounds as I mentioned in #201 (comment)? I get the following logs, which show everything works correctly:

Current Swift SDK version is "5.12.3"
Server health is: ok
    Saved "GameScore" with the following info:
    GameScore ({"createdAt":{"__type":"Date","iso":"2025-10-07T17:35:36.511Z"},"objectId":"xkwx4VHIAQCJmfyR5MIagzsD8Y9aLDZc","points":10,"updatedAt":{"__type":"Date","iso":"2025-10-07T17:35:36.511Z"}})
    Updated "GameScore" with the following info:
    GameScore ({"createdAt":{"__type":"Date","iso":"2025-10-07T17:35:36.511Z"},"objectId":"xkwx4VHIAQCJmfyR5MIagzsD8Y9aLDZc","points":200,"updatedAt":{"__type":"Date","iso":"2025-10-07T17:35:36.540Z"}})
    Saved "GameScore" with
    points Optional(10) successfully
    Saved "GameScore" with
    points Optional(3) successfully
Updated score: Optional(GameScore ({"createdAt":{"__type":"Date","iso":"2025-10-07T17:35:57.059Z"},"objectId":"Dgla6kjDXAos5HBTkGhF5LUeAohf4CAs","points":200,"updatedAt":{"__type":"Date","iso":"2025-10-07T17:35:57.072Z"}}))
Saved "GameScore" with points Optional(10) successfully
Saved "GameScore" with points Optional(3) successfully
Successfully saved: GameScore ({"createdAt":{"__type":"Date","iso":"2025-10-07T17:35:57.093Z"},"objectId":"6X4YTQYUuqbUj6I7iyCPUpCZQtMwNVEv","points":30,"updatedAt":{"__type":"Date","iso":"2025-10-07T17:35:57.093Z"}})
Successfully deleted: GameScore ({"createdAt":{"__type":"Date","iso":"2025-10-07T17:35:57.093Z"},"objectId":"6X4YTQYUuqbUj6I7iyCPUpCZQtMwNVEv","points":30,"updatedAt":{"__type":"Date","iso":"2025-10-07T17:35:57.093Z"}})
Successfully subscribed to new query {"_method":"GET","limit":100,"skip":0,"where":{"points":{"$lt":11}}}
Unsubscribed from {"_method":"GET","limit":100,"skip":0,"where":{"points":{"$lt":11}}}
Successfully pinged server!

On the client-side, did you convert to the async/await initialization?

On the server-side, did you actually setup LiveQuery for the GameScore classname?

Lastly, your code doesn't look correct, you need to store the subscription in your @StateObject var and you are not doing that, so your subscription is never being captured. You should also add more debug statements.

.task {
                    do {
                        let subscribe = try await query.subscribe()
                        subscription = subscribe // You need to store this on your view so it updates the view everytime there's new data. Similar to my Playgrounds example.
print("\(subscribe)"
                    } catch {
                        print(error.localizedDescription)
                    }
                }
.
.
.
// Add more debug statements
Button(action: {
                Task {
do {
                    try await subscription.query.unsubscribe()
print("Unsubscribed")
} catch{
print("\(error)")
}
                }
            }, label: {
                Text("Unsubscribe")
                    .font(.headline)
                    .background(Color.red)
                    .foregroundColor(.white)
                    .padding()
                    .cornerRadius(20.0)
            })

[davidhakki]

@cbaker6 for clarification I definitely don't think anything is wrong with Parse-Swift itself. I am having issues on my end or my understanding with the async implementation/change from Version 4 to 5 strictly for live query.

you need to store the subscription in your https://github.com/StateObject var and you are not doing that, so your subscription is never being captured.

A @StateObject is get-only property by its very nature so the code suggestion is not possible.

On the server-side, did you actually setup LiveQuery for the GameScore classname?

Yes, on my Parse-Swift 4.x.x instance it runs perfectly fine

On the client-side, did you convert to the #74?

Yes, its a breaking change the project won't even build if you don't do so.

Did you test using the Playgrounds as I mentioned in #201 (comment)? I get the following logs, which show everything works correctly:

I've never been able to get the playgrounds to work besides:

I am struggling to wrap my head around a view with dynamic queries running when the playground shows the operation happening before the view exists. With the previous version of ParseSwift it was easy because on the fly I can change the query and re-set object and be done with it.

The playground for example shows this:

But that's only useful if the view I have has a fixed query. That is were I am struggling how can I use this new async format and maintain the flexibility of dynamic queries.

[davidhakki]

Also for further clarification I am able to get livequery working fine in my own view model. So I am just struggling with the native swiftui method

[cbaker6]

But that's only useful if the view I have has a fixed query. That is were I am struggling how can I use this new async format and maintain the flexibility of dynamic queries.

It seems your question is a Swift question as oppose to an issue with Parse-Swift. Similar to

Parse-Swift/ParseSwift.playground/Pages/19 - SwiftUI - LiveQuery.xcplaygroundpage/Contents.swift

Lines 121 to 125 in 12b8e75

	@MainActor
	func startView() async throws {
	let subscribe = try await query.subscribe()
	PlaygroundPage.current.setLiveView(ContentView(subscription: subscribe))
	}

You can setup your query before your present/initialize your view and pass the view the subscription. If you change the query, present another view with the updated subscription. You can also try out @ObservedObject, but some higher level view will need to have a strong reference to the subscription or else it may get deallocated at some point and unintended behavior may occur with your live query

Also for further clarification I am able to get livequery working fine in my own view model. So I am just struggling with the native swiftui method

Your own view model can work well also, the out out-of-the-box view model is just there to help for quick and simple solutions, but not required to use. If you require something more complex, designing a custom view model may be the way to go.