improve generics

Author: stevensJourney

packages/common/src/client/AbstractPowerSyncDatabase.ts

@@ -879,10 +879,9 @@ export abstract class AbstractPowerSyncDatabase extends BaseObserver<PowerSyncDB
     const { mode } = options;
     const builderFactory = WatchedQueryBuilderMap[mode];
     if (!builderFactory) {
-      debugger;
       throw new Error(`Unsupported watch mode: ${mode}`);
     }
-    return builderFactory(this);
+    return builderFactory(this) as WatchedQueryBuilderMap[Mode];
   }
 
   /**

packages/common/src/client/watched/WatchedQuery.ts

@@ -46,8 +46,6 @@ export interface WatchCompatibleQuery<ResultType> {
 }
 
 export interface WatchedQueryOptions<DataType> {
-  query: WatchCompatibleQuery<DataType>;
-
   /**
    * Initial result data which is presented while the initial loading is executing
    */
@@ -85,7 +83,8 @@ export interface WatchedQueryListener extends BaseListener {
   subscriptionsChanged: (counts: SubscriptionCounts) => void;
 }
 
-export interface WatchedQuery<Data> extends BaseObserverInterface<WatchedQueryListener> {
+export interface WatchedQuery<Data, Settings extends WatchedQueryOptions<Data> = WatchedQueryOptions<Data>>
+  extends BaseObserverInterface<WatchedQueryListener> {
   /**
    * Current state of the watched query.
    */
@@ -105,7 +104,7 @@ export interface WatchedQuery<Data> extends BaseObserverInterface<WatchedQueryLi
    * Updates the underlying query options.
    * This will trigger a re-evaluation of the query and update the state.
    */
-  updateSettings(options: WatchedQueryOptions<Data>): Promise<void>;
+  updateSettings(options: Settings): Promise<void>;
 
   /**
    * Close the watched query and end all subscriptions.

packages/common/src/client/watched/processors/AbstractQueryProcessor.ts

@@ -13,17 +13,20 @@ import {
 /**
  * @internal
  */
-export interface AbstractQueryProcessorOptions<Data> {
+export interface AbstractQueryProcessorOptions<
+  Data,
+  Settings extends WatchedQueryOptions<Data> = WatchedQueryOptions<Data>
+> {
   db: AbstractPowerSyncDatabase;
-  watchOptions: WatchedQueryOptions<Data>;
+  watchOptions: Settings;
 }
 
 /**
  * @internal
  */
-export interface LinkQueryOptions<Data> {
+export interface LinkQueryOptions<Data, Settings extends WatchedQueryOptions<Data> = WatchedQueryOptions<Data>> {
   abortSignal: AbortSignal;
-  query: WatchedQueryOptions<Data>;
+  settings: Settings;
 }
 
 type WatchedQueryProcessorListener<Data> = WatchedQuerySubscription<Data> & WatchedQueryListener;
@@ -32,7 +35,10 @@ type WatchedQueryProcessorListener<Data> = WatchedQuerySubscription<Data> & Watc
  * Performs underlying watching and yields a stream of results.
  * @internal
  */
-export abstract class AbstractQueryProcessor<Data = unknown[]>
+export abstract class AbstractQueryProcessor<
+    Data = unknown[],
+    Settings extends WatchedQueryOptions<Data> = WatchedQueryOptions<Data>
+  >
   extends BaseObserver<WatchedQueryProcessorListener<Data>>
   implements WatchedQuery<Data>
 {
@@ -56,7 +62,7 @@ export abstract class AbstractQueryProcessor<Data = unknown[]>
     }, {}) as SubscriptionCounts;
   }
 
-  constructor(protected options: AbstractQueryProcessorOptions<Data>) {
+  constructor(protected options: AbstractQueryProcessorOptions<Data, Settings>) {
     super();
     this.abortController = new AbortController();
     this._closed = false;
@@ -78,15 +84,23 @@ export abstract class AbstractQueryProcessor<Data = unknown[]>
   /**
    * Updates the underlying query.
    */
-  async updateSettings(query: WatchedQueryOptions<Data>) {
+  async updateSettings(settings: Settings) {
     await this.initialized;
 
-    this.options.watchOptions = query;
+    if (!this.state.isLoading) {
+      await this.updateState({
+        isLoading: true,
+        isFetching: this.reportFetching ? true : false,
+        data: settings.placeholderData
+      });
+    }
+
+    this.options.watchOptions = settings;
     this.abortController.abort();
     this.abortController = new AbortController();
     await this.linkQuery({
       abortSignal: this.abortController.signal,
-      query
+      settings
     });
   }
 

packages/common/src/client/watched/processors/ComparisonWatchedQueryBuilder.ts

@@ -1,18 +1,20 @@
 import { AbstractPowerSyncDatabase } from '../../../client/AbstractPowerSyncDatabase.js';
-import { WatchedQuery, WatchedQueryOptions } from '../WatchedQuery.js';
+import { WatchedQuery } from '../WatchedQuery.js';
 import { WatchedQueryBuilder } from '../WatchedQueryBuilder.js';
 import { WatchedQueryComparator } from './comparators.js';
-import { OnChangeQueryProcessor } from './OnChangeQueryProcessor.js';
+import { ComparisonWatchedQuerySettings, OnChangeQueryProcessor } from './OnChangeQueryProcessor.js';
 
 export interface ComparisonWatchProcessorOptions<DataType> {
   comparator?: WatchedQueryComparator<DataType>;
-  watch: WatchedQueryOptions<DataType>;
+  watch: ComparisonWatchedQuerySettings<DataType>;
 }
 
 export class ComparisonWatchedQueryBuilder implements WatchedQueryBuilder {
   constructor(protected db: AbstractPowerSyncDatabase) {}
 
-  build<DataType>(options: ComparisonWatchProcessorOptions<DataType>): WatchedQuery<DataType> {
+  build<DataType>(
+    options: ComparisonWatchProcessorOptions<DataType>
+  ): WatchedQuery<DataType, ComparisonWatchedQuerySettings<DataType>> {
     return new OnChangeQueryProcessor({
       db: this.db,
       comparator: options.comparator ?? {

packages/common/src/client/watched/processors/OnChangeQueryProcessor.ts

@@ -1,11 +1,16 @@
-import { WatchedQueryState } from '../WatchedQuery.js';
+import { WatchCompatibleQuery, WatchedQueryOptions, WatchedQueryState } from '../WatchedQuery.js';
 import { AbstractQueryProcessor, AbstractQueryProcessorOptions, LinkQueryOptions } from './AbstractQueryProcessor.js';
 import { WatchedQueryComparator } from './comparators.js';
 
+export interface ComparisonWatchedQuerySettings<DataType> extends WatchedQueryOptions<DataType> {
+  query: WatchCompatibleQuery<DataType>;
+}
+
 /**
  * @internal
  */
-export interface OnChangeQueryProcessorOptions<Data> extends AbstractQueryProcessorOptions<Data> {
+export interface OnChangeQueryProcessorOptions<Data>
+  extends AbstractQueryProcessorOptions<Data, ComparisonWatchedQuerySettings<Data>> {
   comparator?: WatchedQueryComparator<Data>;
 }
 
@@ -14,7 +19,7 @@ export interface OnChangeQueryProcessorOptions<Data> extends AbstractQueryProces
  * Results are emitted on every change of the relevant tables.
  * @internal
  */
-export class OnChangeQueryProcessor<Data> extends AbstractQueryProcessor<Data> {
+export class OnChangeQueryProcessor<Data> extends AbstractQueryProcessor<Data, ComparisonWatchedQuerySettings<Data>> {
   constructor(protected options: OnChangeQueryProcessorOptions<Data>) {
     super(options);
   }

packages/web/tests/watch.test.ts

@@ -452,4 +452,57 @@ describe('Watch Tests', { sequential: true }, () => {
     expect(notificationCount).equals(1);
     expect(watch.state.data).toHaveLength(1);
   });
+
+  it('should allow updating queries', async () => {
+    // Create sample data
+    await powersync.execute('INSERT INTO assets(id, make, customer_id) VALUES (uuid(), ?, ?)', ['test', uuid()]);
+    await powersync.execute('INSERT INTO assets(id, make, customer_id) VALUES (uuid(), ?, ?)', ['nottest', uuid()]);
+
+    const watch = powersync
+      .incrementalWatch({
+        mode: IncrementalWatchMode.COMPARISON
+      })
+      .build({
+        watch: {
+          query: new GetAllQuery<{ make: string }>({
+            sql: 'SELECT * FROM assets where make = ?',
+            parameters: ['test']
+          }),
+          placeholderData: [],
+          reportFetching: false
+        }
+      });
+
+    expect(watch.state.isFetching).false;
+
+    await vi.waitFor(
+      () => {
+        expect(watch.state.isLoading).false;
+      },
+      { timeout: 1000 }
+    );
+
+    expect(watch.state.data).toHaveLength(1);
+    expect(watch.state.data[0].make).equals('test');
+
+    await watch.updateSettings({
+      placeholderData: [],
+      query: new GetAllQuery<{ make: string }>({
+        sql: 'SELECT * FROM assets where make = ?',
+        parameters: ['nottest']
+      })
+    });
+
+    expect(watch.state.isLoading).true;
+
+    await vi.waitFor(
+      () => {
+        expect(watch.state.isLoading).false;
+      },
+      { timeout: 1000 }
+    );
+
+    expect(watch.state.data).toHaveLength(1);
+    expect(watch.state.data[0].make).equals('nottest');
+  });
 });