@powersync/common 1.20.2 → 1.22.0

package/lib/client/AbstractPowerSyncDatabase.d.ts

@@ -76,6 +76,7 @@ export interface WatchOnChangeHandler {
 }
 export interface PowerSyncDBListener extends StreamingSyncImplementationListener {
     initialized: () => void;
+    schemaChanged: (schema: Schema) => void;
 }
 export interface PowerSyncCloseOptions {
     /**

package/lib/client/AbstractPowerSyncDatabase.js

@@ -14,6 +14,7 @@ import { CrudBatch } from './sync/bucket/CrudBatch.js';
 import { CrudEntry } from './sync/bucket/CrudEntry.js';
 import { CrudTransaction } from './sync/bucket/CrudTransaction.js';
 import { DEFAULT_CRUD_UPLOAD_THROTTLE_MS } from './sync/stream/AbstractStreamingSyncImplementation.js';
+import { runOnSchemaChange } from './runOnSchemaChange.js';
 const POWERSYNC_TABLE_MATCH = /(^ps_data__|^ps_data_local__)/;
 const DEFAULT_DISCONNECT_CLEAR_OPTIONS = {
     clearLocal: true
@@ -211,6 +212,8 @@ export class AbstractPowerSyncDatabase extends BaseObserver {
         }
         this._schema = schema;
         await this.database.execute('SELECT powersync_replace_schema(?)', [JSON.stringify(this.schema.toJSON())]);
+        await this.database.refreshSchema();
+        this.iterateListeners(async (cb) => cb.schemaChanged?.(schema));
     }
     /**
      * Wait for initialization to complete.
@@ -503,7 +506,7 @@ export class AbstractPowerSyncDatabase extends BaseObserver {
         if (!onResult) {
             throw new Error('onResult is required');
         }
-        (async () => {
+        const watchQuery = async (abortSignal) => {
             try {
                 const resolvedTables = await this.resolveTables(sql, parameters, options);
                 // Fetch initial data
@@ -522,13 +525,16 @@ export class AbstractPowerSyncDatabase extends BaseObserver {
                     onError
                 }, {
                     ...(options ?? {}),
-                    tables: resolvedTables
+                    tables: resolvedTables,
+                    // Override the abort signal since we intercept it
+                    signal: abortSignal
                 });
             }
             catch (error) {
                 onError?.(error);
             }
-        })();
+        };
+        runOnSchemaChange(watchQuery, this, options);
     }
     /**
      * Execute a read query every time the source tables are modified.
@@ -537,17 +543,18 @@ export class AbstractPowerSyncDatabase extends BaseObserver {
      */
     watchWithAsyncGenerator(sql, parameters, options) {
         return new EventIterator((eventOptions) => {
-            (async () => {
-                const resolvedTables = await this.resolveTables(sql, parameters, options);
-                // Fetch initial data
-                eventOptions.push(await this.executeReadOnly(sql, parameters));
-                for await (const event of this.onChangeWithAsyncGenerator({
-                    ...(options ?? {}),
-                    tables: resolvedTables
-                })) {
-                    eventOptions.push(await this.executeReadOnly(sql, parameters));
+            const handler = {
+                onResult: (result) => {
+                    eventOptions.push(result);
+                },
+                onError: (error) => {
+                    eventOptions.fail(error);
                 }
-            })();
+            };
+            this.watchWithCallback(sql, parameters, handler, options);
+            options?.signal?.addEventListener('abort', () => {
+                eventOptions.stop();
+            });
         });
     }
     async resolveTables(sql, parameters, options) {

package/lib/client/compilableQueryWatch.d.ts

@@ -0,0 +1,7 @@
+import { CompilableQuery } from './../types/types.js';
+import { AbstractPowerSyncDatabase, SQLWatchOptions } from './AbstractPowerSyncDatabase.js';
+export interface CompilableQueryWatchHandler<T> {
+    onResult: (results: T[]) => void;
+    onError?: (error: Error) => void;
+}
+export declare function compilableQueryWatch<T>(db: AbstractPowerSyncDatabase, query: CompilableQuery<T>, handler: CompilableQueryWatchHandler<T>, options?: SQLWatchOptions): void;

package/lib/client/compilableQueryWatch.js

@@ -0,0 +1,37 @@
+import { runOnSchemaChange } from './runOnSchemaChange.js';
+export function compilableQueryWatch(db, query, handler, options) {
+    const { onResult, onError = (e) => { } } = handler ?? {};
+    if (!onResult) {
+        throw new Error('onResult is required');
+    }
+    const watchQuery = async (abortSignal) => {
+        try {
+            const toSql = query.compile();
+            const resolvedTables = await db.resolveTables(toSql.sql, toSql.parameters, options);
+            // Fetch initial data
+            const result = await query.execute();
+            onResult(result);
+            db.onChangeWithCallback({
+                onChange: async () => {
+                    try {
+                        const result = await query.execute();
+                        onResult(result);
+                    }
+                    catch (error) {
+                        onError(error);
+                    }
+                },
+                onError
+            }, {
+                ...(options ?? {}),
+                tables: resolvedTables,
+                // Override the abort signal since we intercept it
+                signal: abortSignal
+            });
+        }
+        catch (error) {
+            onError(error);
+        }
+    };
+    runOnSchemaChange(watchQuery, db, options);
+}

package/lib/client/runOnSchemaChange.d.ts

@@ -0,0 +1,2 @@
+import { AbstractPowerSyncDatabase, SQLWatchOptions } from './AbstractPowerSyncDatabase.js';
+export declare function runOnSchemaChange(callback: (signal: AbortSignal) => void, db: AbstractPowerSyncDatabase, options?: SQLWatchOptions): void;

package/lib/client/runOnSchemaChange.js

@@ -0,0 +1,23 @@
+export function runOnSchemaChange(callback, db, options) {
+    const triggerWatchedQuery = () => {
+        const abortController = new AbortController();
+        let disposeSchemaListener = null;
+        const stopWatching = () => {
+            abortController.abort('Abort triggered');
+            disposeSchemaListener?.();
+            disposeSchemaListener = null;
+            // Stop listening to upstream abort for this watch
+            options?.signal?.removeEventListener('abort', stopWatching);
+        };
+        options?.signal?.addEventListener('abort', stopWatching);
+        disposeSchemaListener = db.registerListener({
+            schemaChanged: async () => {
+                stopWatching();
+                // Re trigger the watched query (recursively), setTimeout ensures that we don't modify the list of listeners while iterating through them
+                setTimeout(() => triggerWatchedQuery(), 0);
+            }
+        });
+        callback(abortController.signal);
+    };
+    triggerWatchedQuery();
+}

package/lib/db/DBAdapter.d.ts

@@ -90,6 +90,10 @@ export interface DBAdapter extends BaseObserverInterface<DBAdapterListener>, DBG
     readTransaction: <T>(fn: (tx: Transaction) => Promise<T>, options?: DBLockOptions) => Promise<T>;
     writeLock: <T>(fn: (tx: LockContext) => Promise<T>, options?: DBLockOptions) => Promise<T>;
     writeTransaction: <T>(fn: (tx: Transaction) => Promise<T>, options?: DBLockOptions) => Promise<T>;
+    /**
+     * This method refreshes the schema information across all connections. This is for advanced use cases, and should generally not be needed.
+     */
+    refreshSchema: () => Promise<void>;
 }
 export declare function isBatchedUpdateNotification(update: BatchedUpdateNotification | UpdateNotification): update is BatchedUpdateNotification;
 export declare function extractTableUpdates(update: BatchedUpdateNotification | UpdateNotification): string[];

package/lib/db/schema/Schema.d.ts

@@ -1,6 +1,6 @@
 import { RowType, Table } from './Table.js';
 type SchemaType = Record<string, Table<any>>;
-type SchemaTableType<S extends SchemaType> = {
+export type SchemaTableType<S extends SchemaType> = {
     [K in keyof S]: RowType<S[K]>;
 };
 /**

package/lib/index.d.ts

@@ -4,6 +4,8 @@ export * from './client/SQLOpenFactory.js';
 export * from './client/connection/PowerSyncBackendConnector.js';
 export * from './client/connection/PowerSyncCredentials.js';
 export * from './client/sync/bucket/BucketStorageAdapter.js';
+export { runOnSchemaChange } from './client/runOnSchemaChange.js';
+export { CompilableQueryWatchHandler, compilableQueryWatch } from './client/compilableQueryWatch.js';
 export { UpdateType, CrudEntry, OpId } from './client/sync/bucket/CrudEntry.js';
 export * from './client/sync/bucket/SqliteBucketStorage.js';
 export * from './client/sync/bucket/CrudBatch.js';

package/lib/index.js

@@ -4,6 +4,8 @@ export * from './client/SQLOpenFactory.js';
 export * from './client/connection/PowerSyncBackendConnector.js';
 export * from './client/connection/PowerSyncCredentials.js';
 export * from './client/sync/bucket/BucketStorageAdapter.js';
+export { runOnSchemaChange } from './client/runOnSchemaChange.js';
+export { compilableQueryWatch } from './client/compilableQueryWatch.js';
 export { UpdateType, CrudEntry } from './client/sync/bucket/CrudEntry.js';
 export * from './client/sync/bucket/SqliteBucketStorage.js';
 export * from './client/sync/bucket/CrudBatch.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@powersync/common",
-  "version": "1.20.2",
+  "version": "1.22.0",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
     "access": "public"