Merge pull request #38 from powersync-ja/watch-disposable

Return IDisposable from Watch

Author: LucDeCaf

PowerSync/PowerSync.Common/CHANGELOG.md

@@ -1,6 +1,7 @@
 # PowerSync.Common Changelog
 
 ## 0.0.8-alpha.1
+- Return an `IDisposable` from `PowerSync.Watch`, allowing for easier cancellation of watched queries.
 - Replaced the old JSON-based method of extracting type information from queries with using Dapper internally for queries, improving memory usage and execution time for querying.
 - Added non-generic overloads for `GetAll()`, `GetOptional()`, `Get()`, `Watch()` which return `dynamic`:
 

PowerSync/PowerSync.Common/Client/PowerSyncDatabase.cs

@@ -102,6 +102,7 @@ public class PowerSyncDatabase : EventStream<PowerSyncDBEvent>, IPowerSyncDataba
     protected IBucketStorageAdapter BucketStorageAdapter;
 
     protected CancellationTokenSource? syncStreamStatusCts;
+    protected CancellationTokenSource watchSubscriptionCts = new();
 
     protected SyncStatus CurrentStatus;
 
@@ -365,6 +366,16 @@ public async Task Connect(IPowerSyncBackendConnector connector, PowerSyncConnect
         await syncStreamImplementation.Connect(options);
     }
 
+    /// <summary>
+    /// Unsubscribe from all currently watched queries.
+    /// </summary>
+    protected void UnsubscribeAllQueries()
+    {
+        watchSubscriptionCts.Cancel();
+        watchSubscriptionCts.Dispose();
+        watchSubscriptionCts = new();
+    }
+
     public async Task Disconnect()
     {
         await WaitForReady();
@@ -415,7 +426,7 @@ await Database.WriteTransaction(async tx =>
 
         if (Closed) return;
 
-
+        UnsubscribeAllQueries();
         await Disconnect();
         base.Close();
         syncStreamImplementation?.Close();
@@ -671,64 +682,61 @@ public async Task<T> WriteTransaction<T>(Func<ITransaction, Task<T>> fn, DBLockO
     /// Use <see cref="SQLWatchOptions.ThrottleMs"/> to specify the minimum interval between queries.
     /// Source tables are automatically detected using <c>EXPLAIN QUERY PLAN</c>.
     /// </summary>
-    public Task Watch<T>(string query, object?[]? parameters, WatchHandler<T> handler, SQLWatchOptions? options = null)
-        => WatchInternal(query, parameters, handler, options, GetAll<T>);
+    public Task<IDisposable> Watch<T>(string query, object?[]? parameters, WatchHandler<T> handler, SQLWatchOptions? options = null)
+        => Task.Run(() => WatchInternal(query, parameters, handler, options, GetAll<T>));
 
     /// <summary>
     /// Executes a read query every time the source tables are modified.
     /// <para />
     /// Use <see cref="SQLWatchOptions.ThrottleMs"/> to specify the minimum interval between queries.
     /// Source tables are automatically detected using <c>EXPLAIN QUERY PLAN</c>.
     /// </summary>
-    public Task Watch(string query, object?[]? parameters, WatchHandler<dynamic> handler, SQLWatchOptions? options = null)
-        => WatchInternal(query, parameters, handler, options, GetAll);
+    public Task<IDisposable> Watch(string query, object?[]? parameters, WatchHandler<dynamic> handler, SQLWatchOptions? options = null)
+        => Task.Run(() => WatchInternal(query, parameters, handler, options, GetAll));
 
-    private Task WatchInternal<T>(
+    private async Task<IDisposable> WatchInternal<T>(
         string query,
         object?[]? parameters,
         WatchHandler<T> handler,
         SQLWatchOptions? options,
         Func<string, object?[]?, Task<T[]>> getter
     )
     {
-        var tcs = new TaskCompletionSource<bool>();
-        Task.Run(async () =>
+        try
         {
-            try
-            {
-                var resolvedTables = await ResolveTables(query, parameters, options);
-                var result = await getter(query, parameters);
-                handler.OnResult(result);
+            var resolvedTables = await ResolveTables(query, parameters, options);
+            var result = await getter(query, parameters);
+            handler.OnResult(result);
 
-                OnChange(new WatchOnChangeHandler
+            var subscription = OnChange(new WatchOnChangeHandler
+            {
+                OnChange = async (change) =>
                 {
-                    OnChange = async (change) =>
+                    try
                     {
-                        try
-                        {
-                            var result = await getter(query, parameters);
-                            handler.OnResult(result);
-                        }
-                        catch (Exception ex)
-                        {
-                            handler.OnError?.Invoke(ex);
-                        }
-                    },
-                    OnError = handler.OnError
-                }, new SQLWatchOptions
-                {
-                    Tables = resolvedTables,
-                    Signal = options?.Signal,
-                    ThrottleMs = options?.ThrottleMs
-                });
-                tcs.SetResult(true);
-            }
-            catch (Exception ex)
+                        var result = await getter(query, parameters);
+                        handler.OnResult(result);
+                    }
+                    catch (Exception ex)
+                    {
+                        handler.OnError?.Invoke(ex);
+                    }
+                },
+                OnError = handler.OnError
+            }, new SQLWatchOptions
             {
-                handler.OnError?.Invoke(ex);
-            }
-        });
-        return tcs.Task;
+                Tables = resolvedTables,
+                Signal = options?.Signal,
+                ThrottleMs = options?.ThrottleMs
+            });
+
+            return subscription;
+        }
+        catch (Exception ex)
+        {
+            handler.OnError?.Invoke(ex);
+            throw;
+        }
     }
 
     private class ExplainedResult
@@ -776,7 +784,7 @@ public async Task<string[]> ResolveTables(string sql, object?[]? parameters = nu
     /// This is preferred over <see cref="Watch"/> when multiple queries need to be performed
     /// together in response to data changes.
     /// </summary>
-    public void OnChange(WatchOnChangeHandler handler, SQLWatchOptions? options = null)
+    public IDisposable OnChange(WatchOnChangeHandler handler, SQLWatchOptions? options = null)
     {
         var resolvedOptions = options ?? new SQLWatchOptions();
 
@@ -811,13 +819,27 @@ void flushTableUpdates()
             }
         });
 
+        CancellationTokenSource linkedCts;
         if (options?.Signal.HasValue == true)
         {
-            options.Signal.Value.Register(() =>
-            {
-                cts.Cancel();
-            });
+            // Cancel on global CTS cancellation or user token cancellation
+            linkedCts = CancellationTokenSource.CreateLinkedTokenSource(
+                watchSubscriptionCts.Token,
+                options.Signal.Value
+            );
+        }
+        else
+        {
+            // Cancel on global CTS cancellation
+            linkedCts = watchSubscriptionCts;
         }
+
+        var registration = linkedCts.Token.Register(() =>
+        {
+            cts.Cancel();
+        });
+
+        return new WatchSubscription(cts, registration);
     }
 
     private static void HandleTableChanges(HashSet<string> changedTables, HashSet<string> watchedTables, Action<string[]> onDetectedChanges)
@@ -879,3 +901,22 @@ public class WatchOnChangeHandler
     public Func<WatchOnChangeEvent, Task> OnChange { get; set; } = null!;
     public Action<Exception>? OnError { get; set; }
 }
+
+public class WatchSubscription(CancellationTokenSource cts, CancellationTokenRegistration registration) : IDisposable
+{
+    private readonly CancellationTokenSource _cts = cts;
+    private readonly CancellationTokenRegistration _registration = registration;
+    private bool _disposed;
+
+    public bool Disposed { get { return _disposed; } }
+
+    public void Dispose()
+    {
+        if (_disposed) return;
+        _disposed = true;
+
+        _registration.Dispose();
+        _cts.Cancel();
+        _cts.Dispose();
+    }
+}