Added ParseLiveQuerySubscription and refactored accordingly

Author: theSlyest

Parse/Abstractions/Platform/LiveQueries/IParseLiveQueryController.cs

@@ -1,14 +1,17 @@
 using System.Threading;
 using System.Threading.Tasks;
-using Parse.Abstractions.Platform.Objects;
 
 namespace Parse.Abstractions.Platform.LiveQueries;
 
+/// <summary>
+/// Defines an interface for managing LiveQuery connections, subscriptions, and updates
+/// in a Parse Server environment.
+/// </summary>
 public interface IParseLiveQueryController
 {
     Task ConnectAsync(CancellationToken cancellationToken = default);
 
-    Task<int> SubscribeAsync<T>(ParseLiveQuery<T> liveQuery, CancellationToken cancellationToken = default) where T : ParseObject;
+    Task<IParseLiveQuerySubscription> SubscribeAsync<T>(ParseLiveQuery<T> liveQuery, CancellationToken cancellationToken = default) where T : ParseObject;
 
     Task UpdateSubscriptionAsync<T>(ParseLiveQuery<T> liveQuery, int requestId, CancellationToken cancellationToken = default) where T : ParseObject;
 

Parse/Abstractions/Platform/LiveQueries/IParseLiveQuerySubscription.cs

@@ -0,0 +1,70 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Parse.Abstractions.Platform.LiveQueries;
+
+/// <summary>
+/// Represents a live query subscription that is used with Parse's Live Query service.
+/// It allows real-time monitoring and event handling for object changes that match
+/// a specified query.
+/// </summary>
+public interface IParseLiveQuerySubscription
+{
+    /// <summary>
+    /// Represents the Create event for a live query subscription.
+    /// This event is triggered when a new object matching the subscription's query is created.
+    /// </summary>
+    public event EventHandler<IDictionary<string, object>> Create;
+
+    /// <summary>
+    /// Represents the Enter event for a live query subscription.
+    /// This event is triggered when an object that did not previously match the query (and was thus not part of the subscription)
+    /// starts matching the query, typically due to an update.
+    /// </summary>
+    public event EventHandler<IDictionary<string, object>> Enter;
+
+    /// <summary>
+    /// Represents the Update event for a live query subscription.
+    /// This event is triggered when an existing object matching the subscription's query is updated.
+    /// </summary>
+    public event EventHandler<IDictionary<string, object>> Update;
+
+    /// <summary>
+    /// Represents the Leave event for a live query subscription.
+    /// This event is triggered when an object that previously matched the subscription's query
+    /// no longer matches the criteria and is removed.
+    /// </summary>
+    public event EventHandler<IDictionary<string, object>> Leave;
+
+    /// <summary>
+    /// Represents the Delete event for a live query subscription.
+    /// This event is triggered when an object matching the subscription's query is deleted.
+    /// </summary>
+    public event EventHandler<IDictionary<string, object>> Delete;
+
+    /// <summary>
+    /// Updates the current live query subscription with new query parameters,
+    /// effectively modifying the subscription to reflect the provided live query.
+    /// This allows adjustments to the filter or watched keys without unsubscribing
+    /// and re-subscribing.
+    /// </summary>
+    /// <typeparam name="T">The type of the ParseObject associated with the subscription.</typeparam>
+    /// <param name="liveQuery">The updated live query containing new parameters that
+    /// will replace the existing ones for this subscription.</param>
+    /// <param name="cancellationToken">A token to monitor for cancellation requests. If triggered,
+    /// the update process will be halted.</param>
+    /// <returns>A task that represents the asynchronous operation of updating
+    /// the subscription with the new query parameters.</returns>
+    Task UpdateAsync<T>(ParseLiveQuery<T> liveQuery, CancellationToken cancellationToken = default) where T : ParseObject;
+
+    /// <summary>
+    /// Cancels the current live query subscription by unsubscribing from the Parse Live Query server.
+    /// This ensures that the client will no longer receive real-time updates or notifications
+    /// associated with this subscription.
+    /// </summary>
+    /// <param name="cancellationToken">A token to monitor for cancellation requests. If triggered, the cancellation process will halt.</param>
+    /// <returns>A task that represents the asynchronous operation of canceling the subscription.</returns>
+    Task CancelAsync(CancellationToken cancellationToken = default);
+}

Parse/Platform/LiveQueries/ParseLiveQuery.cs

@@ -1,17 +1,12 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
-using System.Diagnostics;
 using System.Linq;
-using System.Net.WebSockets;
-using System.Numerics;
-using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
-using Microsoft.VisualBasic.CompilerServices;
 using Parse.Abstractions.Infrastructure;
+using Parse.Abstractions.Platform.LiveQueries;
 using Parse.Infrastructure.Data;
-using Parse.Infrastructure.Utilities;
 
 namespace Parse;
 
@@ -35,7 +30,7 @@ public class ParseLiveQuery<T> where T : ParseObject
     /// <summary>
     /// Serialized keys watched.
     /// </summary>
-    ReadOnlyCollection<string> KeyWatch { get; }
+    ReadOnlyCollection<string> KeyWatchers { get; }
 
     internal string ClassName { get; }
 
@@ -61,7 +56,7 @@ public ParseLiveQuery(IServiceHub serviceHub, string className, IDictionary<stri
 
         if (watchedKeys is not null)
         {
-            KeyWatch = new ReadOnlyCollection<string>(watchedKeys.ToList());
+            KeyWatchers = new ReadOnlyCollection<string>(watchedKeys.ToList());
         }
     }
 
@@ -70,7 +65,7 @@ public ParseLiveQuery(IServiceHub serviceHub, string className, IDictionary<stri
     /// but the remaining values can be null if they aren't changed in this
     /// composition.
     /// </summary>
-    internal ParseLiveQuery(ParseLiveQuery<T> source, IEnumerable<string> watchedKeys = null)
+    internal ParseLiveQuery(ParseLiveQuery<T> source, IEnumerable<string> watchedKeys = null, Func<IDictionary<string, object>> onCreate = null)
     {
         if (source == null)
         {
@@ -81,14 +76,15 @@ internal ParseLiveQuery(ParseLiveQuery<T> source, IEnumerable<string> watchedKey
         ClassName = source.ClassName;
         Filters = source.Filters;
         KeySelections = source.KeySelections;
+        KeyWatchers = source.KeyWatchers;
 
         if (watchedKeys is { })
         {
-            KeyWatch = new ReadOnlyCollection<string>(MergeKeys(watchedKeys).ToList());
+            KeyWatchers = new ReadOnlyCollection<string>(MergeWatchers(watchedKeys).ToList());
         }
     }
 
-    HashSet<string> MergeKeys(IEnumerable<string> selectedKeys) => new((KeySelections ?? Enumerable.Empty<string>()).Concat(selectedKeys));
+    HashSet<string> MergeWatchers(IEnumerable<string> keys) => new((KeyWatchers ?? Enumerable.Empty<string>()).Concat(keys));
 
     /// <summary>
     /// Add the provided key to the watched fields of returned ParseObjects.
@@ -106,23 +102,13 @@ internal IDictionary<string, object> BuildParameters(bool includeClassName = fal
             result["where"] = PointerOrLocalIdEncoder.Instance.Encode(Filters, Services);
         if (KeySelections != null)
             result["keys"] = String.Join(",", KeySelections.ToArray());
-        if (KeyWatch != null)
-            result["watch"] = String.Join(",", KeyWatch.ToArray());
+        if (KeyWatchers != null)
+            result["watch"] = String.Join(",", KeyWatchers.ToArray());
         if (includeClassName)
             result["className"] = ClassName;
         return result;
     }
 
-    /// <summary>
-    /// Establishes a connection to the Parse Live Query server using the ClientWebSocket instance.
-    /// Prepares and sends a connection message containing required identifiers such as application ID, client key, and session token.
-    /// </summary>
-    /// <returns>A Task representing the asynchronous operation, returning true if the connection attempt is initialized successfully, false otherwise.</returns>
-    public async Task ConnectAsync()
-    {
-        await Services.LiveQueryController.ConnectAsync(CancellationToken.None);
-    }
-
     /// <summary>
     /// Subscribes to the live query, allowing the client to receive real-time updates
     /// for the query's results. This establishes a subscription with the Live Query service.
@@ -131,30 +117,8 @@ public async Task ConnectAsync()
     /// A task representing the asynchronous subscription operation. Upon completion
     /// of the task, the subscription is successfully registered.
     /// </returns>
-    public async Task SubscribeAsync()
-    {
-        RequestId = await Services.LiveQueryController.SubscribeAsync(this, CancellationToken.None);
-    }
-
-    /// <summary>
-    /// Unsubscribes from the live query, stopping the client from receiving further updates related to the subscription.
-    /// </summary>
-    /// <returns>A task representing the asynchronous operation of unsubscribing from the live query.</returns>
-    public async Task UnsubscribeAsync()
-    {
-        if (RequestId > 0)
-            await Services.LiveQueryController.UnsubscribeAsync(RequestId, CancellationToken.None);
-    }
-
-    /// <summary>
-    /// Closes the connection to the live query server asynchronously.
-    /// </summary>
-    /// <returns>
-    /// A task representing the asynchronous operation of closing the live query connection.
-    /// </returns>
-    public async Task CloseAsync()
+    public async Task<IParseLiveQuerySubscription> SubscribeAsync()
     {
-        await Services.LiveQueryController.CloseAsync(CancellationToken.None);
+        return await Services.LiveQueryController.SubscribeAsync(this, CancellationToken.None);
     }
-
 }