@powersync/common 1.54.0 → 1.56.0

package/dist/bundle.node.mjs

@@ -1,4 +1,3 @@
-import { EventIterator } from 'event-iterator';
 import { Buffer } from 'node:buffer';
 
 /**
@@ -2138,11 +2137,7 @@ class SyncStatus {
          */
         const replacer = (_, value) => {
             if (value instanceof Error) {
-                return {
-                    name: value.name,
-                    message: value.message,
-                    stack: value.stack
-                };
+                return this.serializeError(value);
             }
             return value;
         };
@@ -2185,11 +2180,18 @@ class SyncStatus {
         if (typeof error == 'undefined') {
             return undefined;
         }
-        return {
+        const serialized = {
             name: error.name,
             message: error.message,
             stack: error.stack
         };
+        // `Error.cause` can be any value (the spec types it as unknown). Preserve it
+        // so consumers reading uploadError/downloadError keep the failure context.
+        // Recurse for Error causes so the whole chain is flattened the same way.
+        if (typeof error.cause != 'undefined') {
+            serialized.cause = error.cause instanceof Error ? this.serializeError(error.cause) : error.cause;
+        }
+        return serialized;
     }
     static comparePriorities(a, b) {
         return b.priority - a.priority; // Reverse because higher priorities have lower numbers
@@ -2339,6 +2341,210 @@ class ControlledExecutor {
     }
 }
 
+/**
+ * Some JavaScript engines, in particular older versions of React Native, don't support Symbol.asyncIterator.
+ *
+ * For those, users relying on async generators typically lower them with a transpiler and [this polyfill](https://github.com/Azure/azure-sdk-for-js/blob/%40azure/core-asynciterator-polyfill_1.0.2/sdk/core/core-asynciterator-polyfill/src/index.ts#L4-L6).
+ * This definition is compatible with that polyfill, so transpiled apps can use async iterables created by the PowerSync
+ * SDK.
+ */
+const symbolAsyncIterator = Symbol.asyncIterator ?? Symbol.for('Symbol.asyncIterator');
+
+const doneResult = { done: true, value: undefined };
+function valueResult(value) {
+    return { done: false, value };
+}
+/**
+ * Expands a source async iterator by allowing to inject events asynchronously.
+ *
+ * The resulting iterator will emit all events from its source. Additionally though, events can be injected. These
+ * events are dropped once the main iterator completes, but are otherwise forwarded.
+ *
+ * The iterator completes when its source completes, and it supports backpressure by only calling `next()` on the source
+ * in response to a `next()` call from downstream if no pending injected events can be dispatched.
+ */
+function injectable(source) {
+    let sourceIsDone = false;
+    let waiter = undefined; // An active, waiting next() call.
+    // A pending upstream event that couldn't be dispatched because inject() has been called before it was resolved.
+    let pendingSourceEvent = null;
+    let sourceFetchInFlight = false;
+    let pendingInjectedEvents = [];
+    const consumeWaiter = () => {
+        const pending = waiter;
+        waiter = undefined;
+        return pending;
+    };
+    const fetchFromSource = () => {
+        const resolveWaiter = (propagate) => {
+            sourceFetchInFlight = false;
+            const active = consumeWaiter();
+            if (active) {
+                propagate(active);
+            }
+            else {
+                pendingSourceEvent = propagate;
+            }
+        };
+        sourceFetchInFlight = true;
+        const nextFromSource = source.next();
+        nextFromSource.then((value) => {
+            sourceIsDone = value.done == true;
+            resolveWaiter((w) => w.resolve(value));
+        }, (error) => {
+            resolveWaiter((w) => w.reject(error));
+        });
+    };
+    return {
+        next: () => {
+            return new Promise((resolve, reject) => {
+                // First priority: Dispatch ready upstream events.
+                if (sourceIsDone) {
+                    return resolve(doneResult);
+                }
+                if (pendingSourceEvent) {
+                    pendingSourceEvent({ resolve, reject });
+                    pendingSourceEvent = null;
+                    return;
+                }
+                // Second priority: Dispatch injected events
+                if (pendingInjectedEvents.length) {
+                    return resolve(valueResult(pendingInjectedEvents.shift()));
+                }
+                // Nothing pending? Fetch from source
+                waiter = { resolve, reject };
+                if (!sourceFetchInFlight) {
+                    fetchFromSource();
+                }
+            });
+        },
+        inject: (event) => {
+            const pending = consumeWaiter();
+            if (pending != null) {
+                pending.resolve(valueResult(event));
+            }
+            else {
+                pendingInjectedEvents.push(event);
+            }
+        }
+    };
+}
+/**
+ * Splits a byte stream at line endings, emitting each line as a string.
+ */
+function extractJsonLines(source, decoder) {
+    let buffer = '';
+    const pendingLines = [];
+    let isFinalEvent = false;
+    return {
+        next: async () => {
+            while (true) {
+                if (isFinalEvent) {
+                    return doneResult;
+                }
+                {
+                    const first = pendingLines.shift();
+                    if (first) {
+                        return { done: false, value: first };
+                    }
+                }
+                const { done, value } = await source.next();
+                if (done) {
+                    const remaining = buffer.trim();
+                    if (remaining.length != 0) {
+                        isFinalEvent = true;
+                        return { done: false, value: remaining };
+                    }
+                    return doneResult;
+                }
+                const data = decoder.decode(value, { stream: true });
+                buffer += data;
+                const lines = buffer.split('\n');
+                for (let i = 0; i < lines.length - 1; i++) {
+                    const l = lines[i].trim();
+                    if (l.length > 0) {
+                        pendingLines.push(l);
+                    }
+                }
+                buffer = lines[lines.length - 1];
+            }
+        }
+    };
+}
+/**
+ * Splits a concatenated stream of BSON objects by emitting individual objects.
+ */
+function extractBsonObjects(source) {
+    // Fully read but not emitted yet.
+    const completedObjects = [];
+    // Whether source has returned { done: true }. We do the same once completed objects have been emitted.
+    let isDone = false;
+    const lengthBuffer = new DataView(new ArrayBuffer(4));
+    let objectBody = null;
+    // If we're parsing the length field, a number between 1 and 4 (inclusive) describing remaining bytes in the header.
+    // If we're consuming a document, the bytes remaining.
+    let remainingLength = 4;
+    return {
+        async next() {
+            while (true) {
+                // Before fetching new data from upstream, return completed objects.
+                if (completedObjects.length) {
+                    return valueResult(completedObjects.shift());
+                }
+                if (isDone) {
+                    return doneResult;
+                }
+                const upstreamEvent = await source.next();
+                if (upstreamEvent.done) {
+                    isDone = true;
+                    if (objectBody || remainingLength != 4) {
+                        throw new Error('illegal end of stream in BSON object');
+                    }
+                    return doneResult;
+                }
+                const chunk = upstreamEvent.value;
+                for (let i = 0; i < chunk.length;) {
+                    const availableInData = chunk.length - i;
+                    if (objectBody) {
+                        // We're in the middle of reading a BSON document.
+                        const bytesToRead = Math.min(availableInData, remainingLength);
+                        const copySource = new Uint8Array(chunk.buffer, chunk.byteOffset + i, bytesToRead);
+                        objectBody.set(copySource, objectBody.length - remainingLength);
+                        i += bytesToRead;
+                        remainingLength -= bytesToRead;
+                        if (remainingLength == 0) {
+                            completedObjects.push(objectBody);
+                            // Prepare to read another document, starting with its length
+                            objectBody = null;
+                            remainingLength = 4;
+                        }
+                    }
+                    else {
+                        // Copy up to 4 bytes into lengthBuffer, depending on how many we still need.
+                        const bytesToRead = Math.min(availableInData, remainingLength);
+                        for (let j = 0; j < bytesToRead; j++) {
+                            lengthBuffer.setUint8(4 - remainingLength + j, chunk[i + j]);
+                        }
+                        i += bytesToRead;
+                        remainingLength -= bytesToRead;
+                        if (remainingLength == 0) {
+                            // Transition from reading length header to reading document. Subtracting 4 because the length of the
+                            // header is included in length.
+                            const length = lengthBuffer.getInt32(0, true /* little endian */);
+                            remainingLength = length - 4;
+                            if (remainingLength < 1) {
+                                throw new Error(`invalid length for bson: ${length}`);
+                            }
+                            objectBody = new Uint8Array(length);
+                            new DataView(objectBody.buffer).setInt32(0, length, true);
+                        }
+                    }
+                }
+            }
+        }
+    };
+}
+
 /**
  * Throttle a function to be called at most once every "wait" milliseconds,
  * on the trailing edge.
@@ -2358,45 +2564,128 @@ function throttleTrailing(func, wait) {
     };
 }
 function asyncNotifier() {
-    let waitingConsumer = null;
-    let hasPendingNotification = false;
+    const queue = new EventQueue();
     return {
         notify() {
-            if (waitingConsumer != null) {
-                waitingConsumer();
-                waitingConsumer = null;
-            }
+            if (queue.countOutstandingEvents > 0) ;
             else {
-                hasPendingNotification = true;
+                queue.notify();
             }
         },
         waitForNotification(signal) {
-            return new Promise((resolve) => {
-                if (waitingConsumer != null) {
-                    throw new Error('Illegal call to waitForNotification, already has a waiter.');
-                }
-                if (signal.aborted) {
-                    resolve();
+            return queue.waitForEvent(signal);
+        }
+    };
+}
+class EventQueue {
+    options;
+    waitingConsumer;
+    outstandingEvents;
+    constructor(options = {}) {
+        this.options = options;
+        this.outstandingEvents = [];
+    }
+    /**
+     * The amount of buffered events not yet dispatched to listeners.
+     */
+    get countOutstandingEvents() {
+        return this.outstandingEvents.length;
+    }
+    notifyInner(dispatch) {
+        const existing = this.waitingConsumer;
+        this.waitingConsumer = undefined;
+        const dispatchAndNotifyListeners = (waiter) => {
+            dispatch(waiter);
+            this.options.eventDelivered?.();
+        };
+        if (existing) {
+            dispatchAndNotifyListeners(existing);
+        }
+        else {
+            this.outstandingEvents.push(dispatchAndNotifyListeners);
+        }
+    }
+    notify(value) {
+        this.notifyInner((l) => l.resolve(value));
+    }
+    notifyError(error) {
+        this.notifyInner((l) => l.reject(error));
+    }
+    waitForEvent(signal) {
+        return new Promise((resolve, reject) => {
+            if (this.waitingConsumer != null) {
+                throw new Error('Illegal call to waitForEvent, already has a waiter.');
+            }
+            const complete = () => {
+                signal?.removeEventListener('abort', onAbort);
+            };
+            const onAbort = () => {
+                complete();
+                this.waitingConsumer = undefined;
+                resolve(undefined);
+            };
+            const waiter = {
+                resolve: (value) => {
+                    complete();
+                    resolve(value);
+                },
+                reject: (error) => {
+                    complete();
+                    reject(error);
                 }
-                else if (hasPendingNotification) {
-                    resolve();
-                    hasPendingNotification = false;
+            };
+            if (signal.aborted) {
+                resolve(undefined);
+            }
+            else if (this.countOutstandingEvents > 0) {
+                const [event] = this.outstandingEvents.splice(0, 1);
+                event(waiter);
+            }
+            else {
+                this.waitingConsumer = waiter;
+                signal.addEventListener('abort', onAbort);
+            }
+        });
+    }
+    /**
+     * Creates an async iterable backed by event queues.
+     *
+     * @param run A function invoked for every new listener. It receives a queue backing the async iterator.
+     * @param abort An additional abort signal. The `run` callback will also be aborted when `AsyncIterator.return` is
+     * called.
+     * @returns An object conforming to the async iterable protocol.
+     */
+    static queueBasedAsyncIterable(run, abort) {
+        return {
+            [symbolAsyncIterator]: () => {
+                const queue = new EventQueue();
+                const controller = new AbortController();
+                function dispose() {
+                    controller.abort();
+                    abort?.removeEventListener('abort', dispose);
                 }
-                else {
-                    function complete() {
-                        signal.removeEventListener('abort', onAbort);
-                        resolve();
+                if (abort) {
+                    if (abort.aborted) {
+                        controller.abort();
                     }
-                    function onAbort() {
-                        waitingConsumer = null;
-                        resolve();
+                    else {
+                        abort.addEventListener('abort', dispose);
                     }
-                    waitingConsumer = complete;
-                    signal.addEventListener('abort', onAbort);
                 }
-            });
-        }
-    };
+                run(queue, controller.signal);
+                return {
+                    async next() {
+                        const event = await queue.waitForEvent(controller.signal);
+                        return event == null ? doneResult : valueResult(event);
+                    },
+                    async return() {
+                        dispose();
+                        return doneResult;
+                    }
+                };
+            }
+        };
+    }
 }
 
 /**
@@ -8256,7 +8545,7 @@ function requireDist () {
 
 var distExports = requireDist();
 
-var version = "1.54.0";
+var version = "1.56.0";
 var PACKAGE = {
 	version: version};
 
@@ -8423,201 +8712,6 @@ class WebsocketClientTransport {
     }
 }
 
-const doneResult = { done: true, value: undefined };
-function valueResult(value) {
-    return { done: false, value };
-}
-/**
- * Expands a source async iterator by allowing to inject events asynchronously.
- *
- * The resulting iterator will emit all events from its source. Additionally though, events can be injected. These
- * events are dropped once the main iterator completes, but are otherwise forwarded.
- *
- * The iterator completes when its source completes, and it supports backpressure by only calling `next()` on the source
- * in response to a `next()` call from downstream if no pending injected events can be dispatched.
- */
-function injectable(source) {
-    let sourceIsDone = false;
-    let waiter = undefined; // An active, waiting next() call.
-    // A pending upstream event that couldn't be dispatched because inject() has been called before it was resolved.
-    let pendingSourceEvent = null;
-    let sourceFetchInFlight = false;
-    let pendingInjectedEvents = [];
-    const consumeWaiter = () => {
-        const pending = waiter;
-        waiter = undefined;
-        return pending;
-    };
-    const fetchFromSource = () => {
-        const resolveWaiter = (propagate) => {
-            sourceFetchInFlight = false;
-            const active = consumeWaiter();
-            if (active) {
-                propagate(active);
-            }
-            else {
-                pendingSourceEvent = propagate;
-            }
-        };
-        sourceFetchInFlight = true;
-        const nextFromSource = source.next();
-        nextFromSource.then((value) => {
-            sourceIsDone = value.done == true;
-            resolveWaiter((w) => w.resolve(value));
-        }, (error) => {
-            resolveWaiter((w) => w.reject(error));
-        });
-    };
-    return {
-        next: () => {
-            return new Promise((resolve, reject) => {
-                // First priority: Dispatch ready upstream events.
-                if (sourceIsDone) {
-                    return resolve(doneResult);
-                }
-                if (pendingSourceEvent) {
-                    pendingSourceEvent({ resolve, reject });
-                    pendingSourceEvent = null;
-                    return;
-                }
-                // Second priority: Dispatch injected events
-                if (pendingInjectedEvents.length) {
-                    return resolve(valueResult(pendingInjectedEvents.shift()));
-                }
-                // Nothing pending? Fetch from source
-                waiter = { resolve, reject };
-                if (!sourceFetchInFlight) {
-                    fetchFromSource();
-                }
-            });
-        },
-        inject: (event) => {
-            const pending = consumeWaiter();
-            if (pending != null) {
-                pending.resolve(valueResult(event));
-            }
-            else {
-                pendingInjectedEvents.push(event);
-            }
-        }
-    };
-}
-/**
- * Splits a byte stream at line endings, emitting each line as a string.
- */
-function extractJsonLines(source, decoder) {
-    let buffer = '';
-    const pendingLines = [];
-    let isFinalEvent = false;
-    return {
-        next: async () => {
-            while (true) {
-                if (isFinalEvent) {
-                    return doneResult;
-                }
-                {
-                    const first = pendingLines.shift();
-                    if (first) {
-                        return { done: false, value: first };
-                    }
-                }
-                const { done, value } = await source.next();
-                if (done) {
-                    const remaining = buffer.trim();
-                    if (remaining.length != 0) {
-                        isFinalEvent = true;
-                        return { done: false, value: remaining };
-                    }
-                    return doneResult;
-                }
-                const data = decoder.decode(value, { stream: true });
-                buffer += data;
-                const lines = buffer.split('\n');
-                for (let i = 0; i < lines.length - 1; i++) {
-                    const l = lines[i].trim();
-                    if (l.length > 0) {
-                        pendingLines.push(l);
-                    }
-                }
-                buffer = lines[lines.length - 1];
-            }
-        }
-    };
-}
-/**
- * Splits a concatenated stream of BSON objects by emitting individual objects.
- */
-function extractBsonObjects(source) {
-    // Fully read but not emitted yet.
-    const completedObjects = [];
-    // Whether source has returned { done: true }. We do the same once completed objects have been emitted.
-    let isDone = false;
-    const lengthBuffer = new DataView(new ArrayBuffer(4));
-    let objectBody = null;
-    // If we're parsing the length field, a number between 1 and 4 (inclusive) describing remaining bytes in the header.
-    // If we're consuming a document, the bytes remaining.
-    let remainingLength = 4;
-    return {
-        async next() {
-            while (true) {
-                // Before fetching new data from upstream, return completed objects.
-                if (completedObjects.length) {
-                    return valueResult(completedObjects.shift());
-                }
-                if (isDone) {
-                    return doneResult;
-                }
-                const upstreamEvent = await source.next();
-                if (upstreamEvent.done) {
-                    isDone = true;
-                    if (objectBody || remainingLength != 4) {
-                        throw new Error('illegal end of stream in BSON object');
-                    }
-                    return doneResult;
-                }
-                const chunk = upstreamEvent.value;
-                for (let i = 0; i < chunk.length;) {
-                    const availableInData = chunk.length - i;
-                    if (objectBody) {
-                        // We're in the middle of reading a BSON document.
-                        const bytesToRead = Math.min(availableInData, remainingLength);
-                        const copySource = new Uint8Array(chunk.buffer, chunk.byteOffset + i, bytesToRead);
-                        objectBody.set(copySource, objectBody.length - remainingLength);
-                        i += bytesToRead;
-                        remainingLength -= bytesToRead;
-                        if (remainingLength == 0) {
-                            completedObjects.push(objectBody);
-                            // Prepare to read another document, starting with its length
-                            objectBody = null;
-                            remainingLength = 4;
-                        }
-                    }
-                    else {
-                        // Copy up to 4 bytes into lengthBuffer, depending on how many we still need.
-                        const bytesToRead = Math.min(availableInData, remainingLength);
-                        for (let j = 0; j < bytesToRead; j++) {
-                            lengthBuffer.setUint8(4 - remainingLength + j, chunk[i + j]);
-                        }
-                        i += bytesToRead;
-                        remainingLength -= bytesToRead;
-                        if (remainingLength == 0) {
-                            // Transition from reading length header to reading document. Subtracting 4 because the length of the
-                            // header is included in length.
-                            const length = lengthBuffer.getInt32(0, true /* little endian */);
-                            remainingLength = length - 4;
-                            if (remainingLength < 1) {
-                                throw new Error(`invalid length for bson: ${length}`);
-                            }
-                            objectBody = new Uint8Array(length);
-                            new DataView(objectBody.buffer).setInt32(0, length, true);
-                        }
-                    }
-                }
-            }
-        }
-    };
-}
-
 const POWERSYNC_TRAILING_SLASH_MATCH = /\/+$/;
 const POWERSYNC_JS_VERSION = PACKAGE.version;
 const SYNC_QUEUE_REQUEST_HIGH_WATER = 10;
@@ -8836,8 +8930,19 @@ class AbstractRemote {
         let pendingSocket = null;
         let keepAliveTimeout;
         let rsocket = null;
-        let queue = null;
+        let paused = false;
+        const queue = new EventQueue({
+            eventDelivered: () => {
+                if (queue.countOutstandingEvents <= SYNC_QUEUE_REQUEST_LOW_WATER) {
+                    paused = false;
+                    requestMore();
+                }
+            }
+        });
         let didClose = false;
+        let connectionEstablished = false;
+        let pendingEventsCount = syncQueueRequestSize;
+        let res = null;
         const abortRequest = () => {
             if (didClose) {
                 return;
@@ -8850,10 +8955,23 @@ class AbstractRemote {
             if (rsocket) {
                 rsocket.close();
             }
-            if (queue) {
-                queue.stop();
-            }
+            // Send a bogus event to the queue to ensure a pending listener gets woken up. We check for didClose and would
+            // return a doneEvent.
+            queue.notify(null);
         };
+        function push(event) {
+            queue.notify(event);
+            if (queue.countOutstandingEvents >= SYNC_QUEUE_REQUEST_HIGH_WATER) {
+                paused = true;
+            }
+        }
+        function requestMore() {
+            const delta = syncQueueRequestSize - pendingEventsCount;
+            if (!paused && delta > 0) {
+                res?.request(delta);
+                pendingEventsCount = syncQueueRequestSize;
+            }
+        }
         // Handle upstream abort
         if (options.abortSignal.aborted) {
             throw new AbortOperation('Connection request aborted');
@@ -8908,25 +9026,19 @@ class AbstractRemote {
         // Helps to prevent double close scenarios
         rsocket.onClose(() => (rsocket = null));
         return await new Promise((resolve, reject) => {
-            let connectionEstablished = false;
-            let pendingEventsCount = syncQueueRequestSize;
-            let paused = false;
-            let res = null;
-            function requestMore() {
-                const delta = syncQueueRequestSize - pendingEventsCount;
-                if (!paused && delta > 0) {
-                    res?.request(delta);
-                    pendingEventsCount = syncQueueRequestSize;
+            const queueAsIterator = {
+                next: async () => {
+                    if (didClose)
+                        return doneResult;
+                    const notification = await queue.waitForEvent(options.abortSignal);
+                    if (didClose) {
+                        return doneResult;
+                    }
+                    else {
+                        return valueResult(notification);
+                    }
                 }
-            }
-            const events = new EventIterator((q) => {
-                queue = q;
-                q.on('highWater', () => (paused = true));
-                q.on('lowWater', () => {
-                    paused = false;
-                    requestMore();
-                });
-            }, { highWaterMark: SYNC_QUEUE_REQUEST_HIGH_WATER, lowWaterMark: SYNC_QUEUE_REQUEST_LOW_WATER })[Symbol.asyncIterator]();
+            };
             res = rsocket.requestStream({
                 data: toBuffer(options.data),
                 metadata: toBuffer({
@@ -8962,11 +9074,11 @@ class AbstractRemote {
                     // The connection is active
                     if (!connectionEstablished) {
                         connectionEstablished = true;
-                        resolve(events);
+                        resolve(queueAsIterator);
                     }
                     const { data } = payload;
                     if (data) {
-                        queue.push(data);
+                        push(data);
                     }
                     // Less events are now pending
                     pendingEventsCount--;
@@ -10564,7 +10676,7 @@ class AbstractPowerSyncDatabase extends BaseObserver {
             this.logger.warn('Schema validation failed. Unexpected behaviour could occur', ex);
         }
         this._schema = schema;
-        await this.database.execute('SELECT powersync_replace_schema(?)', [JSON.stringify(this.schema.toJSON())]);
+        await this.database.writeTransaction((tx) => tx.execute('SELECT powersync_replace_schema(?)', [JSON.stringify(this.schema.toJSON())]));
         await this.database.refreshSchema();
         this.iterateListeners(async (cb) => cb.schemaChanged?.(schema));
     }
@@ -10734,7 +10846,7 @@ class AbstractPowerSyncDatabase extends BaseObserver {
      * @returns A transaction of CRUD operations to upload, or null if there are none
      */
     async getNextCrudTransaction() {
-        const iterator = this.getCrudTransactions()[Symbol.asyncIterator]();
+        const iterator = this.getCrudTransactions()[symbolAsyncIterator]();
         return (await iterator.next()).value;
     }
     /**
@@ -10770,7 +10882,7 @@ class AbstractPowerSyncDatabase extends BaseObserver {
      */
     getCrudTransactions() {
         return {
-            [Symbol.asyncIterator]: () => {
+            [symbolAsyncIterator]: () => {
                 let lastCrudItemId = -1;
                 const sql = `
 WITH RECURSIVE crud_entries AS (
@@ -11084,20 +11196,17 @@ SELECT * FROM crud_entries;
      * @returns An AsyncIterable that yields QueryResults whenever the data changes
      */
     watchWithAsyncGenerator(sql, parameters, options) {
-        return new EventIterator((eventOptions) => {
+        return EventQueue.queueBasedAsyncIterable((queue, abort) => {
             const handler = {
                 onResult: (result) => {
-                    eventOptions.push(result);
+                    queue.notify(result);
                 },
                 onError: (error) => {
-                    eventOptions.fail(error);
+                    queue.notifyError(error);
                 }
             };
-            this.watchWithCallback(sql, parameters, handler, options);
-            options?.signal?.addEventListener('abort', () => {
-                eventOptions.stop();
-            });
-        });
+            this.watchWithCallback(sql, parameters, handler, { ...options, signal: abort });
+        }, options?.signal);
     }
     /**
      * Resolves the list of tables that are used in a SQL query.
@@ -11187,28 +11296,23 @@ SELECT * FROM crud_entries;
      * This is preferred over {@link AbstractPowerSyncDatabase.watchWithAsyncGenerator} when multiple queries need to be
      * performed together when data is changed.
      *
-     * Note: do not declare this as `async *onChange` as it will not work in React Native.
-     *
      * @param options - Options for configuring watch behavior
      * @returns An AsyncIterable that yields change events whenever the specified tables change
      */
+    // Note: do not declare this as `async *onChange` as it will not work in React Native.
     onChangeWithAsyncGenerator(options) {
-        const resolvedOptions = options ?? {};
-        return new EventIterator((eventOptions) => {
-            const dispose = this.onChangeWithCallback({
+        return EventQueue.queueBasedAsyncIterable((queue, abort) => {
+            this.onChangeWithCallback({
                 onChange: (event) => {
-                    eventOptions.push(event);
+                    queue.notify(event);
                 },
                 onError: (error) => {
-                    eventOptions.fail(error);
+                    queue.notifyError(error);
                 }
-            }, options);
-            resolvedOptions.signal?.addEventListener('abort', () => {
-                eventOptions.stop();
-                // Maybe fail?
-            });
-            return () => dispose();
-        });
+            }, { ...options, signal: abort });
+            // Note: We don't have to track the dispose function returned by onChangeWithCallback, it cleans up
+            // after the abort signal completes.
+        }, options?.signal);
     }
     handleTableChanges(changedTables, watchedTables, onDetectedChanges) {
         if (changedTables.size > 0) {