cleanup interfaces

Author: stevensJourney

packages/common/src/client/AbstractPowerSyncDatabase.ts

@@ -109,6 +109,16 @@ export interface WatchOnChangeHandler {
   onError?: (error: Error) => void;
 }
 
+export interface ComparatorWatchOptions<DataType> {
+  mode: 'comparison';
+  comparator?: WatchedQueryComparator<DataType>;
+}
+
+export interface IncrementalWatchOptions<DataType> {
+  watch: WatchedQueryOptions<DataType>;
+  processor?: ComparatorWatchOptions<DataType>;
+}
+
 export interface PowerSyncDBListener extends StreamingSyncImplementationListener {
   initialized: () => void;
   schemaChanged: (schema: Schema) => void;
@@ -872,23 +882,19 @@ export abstract class AbstractPowerSyncDatabase extends BaseObserver<PowerSyncDB
   }
 
   // TODO names and types
-  incrementalWatch<DataType>(
-    options: { watchOptions: WatchedQueryOptions<DataType> } & {
-      mode: 'comparison';
-      comparator?: WatchedQueryComparator<DataType>;
-    }
-  ): WatchedQuery<DataType> {
-    switch (options.mode) {
+  incrementalWatch<DataType>(options: IncrementalWatchOptions<DataType>): WatchedQuery<DataType> {
+    const { watch, processor } = options;
+
+    switch (options.processor?.mode) {
       case 'comparison':
+      default:
         return new OnChangeQueryProcessor({
           db: this,
-          comparator: options.comparator ?? {
+          comparator: processor?.comparator ?? {
             checkEquality: (a, b) => JSON.stringify(a) == JSON.stringify(b)
           },
-          watchOptions: options.watchOptions
+          watchOptions: watch
         });
-      default:
-        throw new Error(`Invalid mode specified ${options.mode}`);
     }
   }
 

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

@@ -1,4 +1,3 @@
-import { CompiledQuery } from 'src/types/types.js';
 import { BaseListener, BaseObserverInterface } from '../../utils/BaseObserver.js';
 
 export interface WatchedQueryState<Data> {
@@ -26,14 +25,19 @@ export interface WatchedQueryState<Data> {
   data: Data;
 }
 
+export interface WatchCompiledQuery {
+  sql: string;
+  parameters: any[];
+}
 /**
+ *
  * @internal
  * Similar to {@link CompatibleQuery}, except the `execute` method
  * does not enforce an Array result type.
  */
 export interface WatchCompatibleQuery<ResultType> {
-  execute(compiled: CompiledQuery): Promise<ResultType>;
-  compile(): CompiledQuery;
+  execute(compiled: WatchCompiledQuery): Promise<ResultType>;
+  compile(): WatchCompiledQuery;
 }
 
 /**

packages/react/src/QueryStore.ts

@@ -20,8 +20,7 @@ export class QueryStore {
     }
 
     const watchedQuery = this.db.incrementalWatch({
-      mode: 'comparison',
-      watchOptions: {
+      watch: {
         query,
         placeholderData: [],
         throttleMs: options.throttleMs

packages/react/src/hooks/useQuery.ts

@@ -121,8 +121,7 @@ const useWatchedQuery = <RowType = unknown>(
   const createWatchedQuery = React.useCallback(() => {
     return powerSync.incrementalWatch<RowType[]>({
       // This always enables comparison. Might want to be able to disable this??
-      mode: 'comparison',
-      watchOptions: {
+      watch: {
         placeholderData: [],
         query,
         throttleMs: hookOptions.throttleMs,
@@ -182,14 +181,20 @@ export const constructCompatibleQuery = <RowType>(
       return {
         compile: () => ({
           sql: query,
-          parameters: parameters
+          parameters
         }),
         execute: () => powerSync.getAll(query, parameters)
       };
     } else {
       return {
         // Generics differ a bit but holistically this is the same
-        compile: () => query.compile(),
+        compile: () => {
+          const compiled = query.compile();
+          return {
+            sql: compiled.sql,
+            parameters: [...compiled.parameters]
+          };
+        },
         execute: () => query.execute()
       };
     }

packages/web/tests/watch.test.ts

@@ -327,15 +327,15 @@ describe('Watch Tests', { sequential: true }, () => {
 
   it('should stream watch results', async () => {
     const watch = powersync.incrementalWatch({
-      mode: 'comparison',
-      watchOptions: {
+      watch: {
         query: {
           compile: () => ({
             sql: 'SELECT * FROM assets',
             parameters: []
           }),
           execute: ({ sql, parameters }) => powersync.getAll(sql, parameters)
-        }
+        },
+        placeholderData: []
       }
     });
 
@@ -369,8 +369,16 @@ describe('Watch Tests', { sequential: true }, () => {
 
   it('should only report updates for relevant changes', async () => {
     const watch = powersync.incrementalWatch({
-      sql: 'SELECT * FROM assets where make = ?',
-      parameters: ['test']
+      watch: {
+        query: {
+          compile: () => ({
+            sql: 'SELECT * FROM assets where make = ?',
+            parameters: ['test']
+          }),
+          execute: ({ sql, parameters }) => powersync.getAll(sql, parameters)
+        },
+        placeholderData: []
+      }
     });
 
     let notificationCount = 0;
@@ -398,9 +406,17 @@ describe('Watch Tests', { sequential: true }, () => {
 
   it('should not report fetching status', async () => {
     const watch = powersync.incrementalWatch({
-      sql: 'SELECT * FROM assets where make = ?',
-      parameters: ['test'],
-      reportFetching: false
+      watch: {
+        query: {
+          compile: () => ({
+            sql: 'SELECT * FROM assets where make = ?',
+            parameters: ['test']
+          }),
+          execute: ({ sql, parameters }) => powersync.getAll(sql, parameters)
+        },
+        placeholderData: [],
+        reportFetching: false
+      }
     });
 
     expect(watch.state.isFetching).false;