@powersync/common 0.0.0-dev-20250714151300 → 0.0.0-dev-20250715104704

package/lib/db/schema/Schema.js

@@ -1,3 +1,4 @@
+import { RawTable } from './RawTable.js';
 /**
  * A schema is a collection of tables. It is used to define the structure of a database.
  */
@@ -8,6 +9,7 @@ export class Schema {
     types;
     props;
     tables;
+    rawTables;
     constructor(tables) {
         if (Array.isArray(tables)) {
             /*
@@ -26,6 +28,22 @@ export class Schema {
             this.props = tables;
             this.tables = this.convertToClassicTables(this.props);
         }
+        this.rawTables = [];
+    }
+    /**
+     * Adds raw tables to this schema. Raw tables are identified by their name, but entirely managed by the application
+     * developer instead of automatically by PowerSync.
+     * Since raw tables are not backed by JSON, running complex queries on them may be more efficient. Further, they allow
+     * using client-side table and column constraints.
+     * Note that raw tables are only supported when using the new `SyncClientImplementation.rust` sync client.
+     *
+     * @param tables An object of (table name, raw table definition) entries.
+     * @experimental Note that the raw tables API is still experimental and may change in the future.
+     */
+    withRawTables(tables) {
+        for (const [name, rawTableDefinition] of Object.entries(tables)) {
+            this.rawTables.push(new RawTable(name, rawTableDefinition));
+        }
     }
     validate() {
         for (const table of this.tables) {
@@ -35,7 +53,8 @@ export class Schema {
     toJSON() {
         return {
             // This is required because "name" field is not present in TableV2
-            tables: this.tables.map((t) => t.toJSON())
+            tables: this.tables.map((t) => t.toJSON()),
+            raw_tables: this.rawTables
         };
     }
     convertToClassicTables(props) {

package/lib/index.d.ts

@@ -29,15 +29,9 @@ export * from './db/schema/IndexedColumn.js';
 export * from './db/schema/Schema.js';
 export * from './db/schema/Table.js';
 export * from './db/schema/TableV2.js';
-export * from './client/Query.js';
-export * from './client/watched/GetAllQuery.js';
-export * from './client/watched/processors/AbstractQueryProcessor.js';
-export * from './client/watched/processors/comparators.js';
-export * from './client/watched/processors/DifferentialQueryProcessor.js';
-export * from './client/watched/processors/OnChangeQueryProcessor.js';
-export * from './client/watched/WatchedQuery.js';
 export * from './utils/AbortOperation.js';
 export * from './utils/BaseObserver.js';
+export * from './utils/ControlledExecutor.js';
 export * from './utils/DataStream.js';
 export * from './utils/Logger.js';
 export * from './utils/parseQuery.js';

package/lib/index.js

@@ -29,15 +29,9 @@ export * from './db/schema/IndexedColumn.js';
 export * from './db/schema/Schema.js';
 export * from './db/schema/Table.js';
 export * from './db/schema/TableV2.js';
-export * from './client/Query.js';
-export * from './client/watched/GetAllQuery.js';
-export * from './client/watched/processors/AbstractQueryProcessor.js';
-export * from './client/watched/processors/comparators.js';
-export * from './client/watched/processors/DifferentialQueryProcessor.js';
-export * from './client/watched/processors/OnChangeQueryProcessor.js';
-export * from './client/watched/WatchedQuery.js';
 export * from './utils/AbortOperation.js';
 export * from './utils/BaseObserver.js';
+export * from './utils/ControlledExecutor.js';
 export * from './utils/DataStream.js';
 export * from './utils/Logger.js';
 export * from './utils/parseQuery.js';

package/lib/utils/BaseObserver.d.ts

@@ -1,14 +1,15 @@
 export interface Disposable {
-    dispose: () => Promise<void> | void;
+    dispose: () => Promise<void>;
 }
-export type BaseListener = Record<string, ((...event: any) => any) | undefined>;
 export interface BaseObserverInterface<T extends BaseListener> {
     registerListener(listener: Partial<T>): () => void;
 }
+export type BaseListener = {
+    [key: string]: ((...event: any) => any) | undefined;
+};
 export declare class BaseObserver<T extends BaseListener = BaseListener> implements BaseObserverInterface<T> {
     protected listeners: Set<Partial<T>>;
     constructor();
-    dispose(): void;
     /**
      * Register a listener for updates to the PowerSync client.
      */

package/lib/utils/BaseObserver.js

@@ -1,9 +1,6 @@
 export class BaseObserver {
     listeners = new Set();
     constructor() { }
-    dispose() {
-        this.listeners.clear();
-    }
     /**
      * Register a listener for updates to the PowerSync client.
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@powersync/common",
-  "version": "0.0.0-dev-20250714151300",
+  "version": "0.0.0-dev-20250715104704",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
     "access": "public"

package/lib/client/CustomQuery.d.ts

@@ -1,25 +0,0 @@
-import { AbstractPowerSyncDatabase } from './AbstractPowerSyncDatabase.js';
-import { Query, StandardWatchedQueryOptions } from './Query.js';
-import { DifferentialQueryProcessor, DifferentialWatchedQueryOptions } from './watched/processors/DifferentialQueryProcessor.js';
-import { OnChangeQueryProcessor } from './watched/processors/OnChangeQueryProcessor.js';
-import { WatchCompatibleQuery, WatchedQueryOptions } from './watched/WatchedQuery.js';
-/**
- * @internal
- */
-export interface CustomQueryOptions<RowType> {
-    db: AbstractPowerSyncDatabase;
-    query: WatchCompatibleQuery<RowType[]>;
-}
-/**
- * @internal
- */
-export declare class CustomQuery<RowType> implements Query<RowType> {
-    protected options: CustomQueryOptions<RowType>;
-    constructor(options: CustomQueryOptions<RowType>);
-    protected resolveOptions(options: WatchedQueryOptions): {
-        reportFetching: boolean | undefined;
-        throttleMs: number | undefined;
-    };
-    watch(watchOptions: StandardWatchedQueryOptions<RowType>): OnChangeQueryProcessor<RowType[]>;
-    differentialWatch(differentialWatchOptions: DifferentialWatchedQueryOptions<RowType>): DifferentialQueryProcessor<RowType>;
-}

package/lib/client/CustomQuery.js

@@ -1,41 +0,0 @@
-import { FalsyComparator } from './watched/processors/comparators.js';
-import { DifferentialQueryProcessor } from './watched/processors/DifferentialQueryProcessor.js';
-import { OnChangeQueryProcessor } from './watched/processors/OnChangeQueryProcessor.js';
-import { DEFAULT_WATCH_QUERY_OPTIONS } from './watched/WatchedQuery.js';
-/**
- * @internal
- */
-export class CustomQuery {
-    options;
-    constructor(options) {
-        this.options = options;
-    }
-    resolveOptions(options) {
-        return {
-            reportFetching: options?.reportFetching ?? DEFAULT_WATCH_QUERY_OPTIONS.reportFetching,
-            throttleMs: options?.throttleMs ?? DEFAULT_WATCH_QUERY_OPTIONS.throttleMs
-        };
-    }
-    watch(watchOptions) {
-        return new OnChangeQueryProcessor({
-            db: this.options.db,
-            comparator: watchOptions?.comparator ?? FalsyComparator,
-            placeholderData: watchOptions?.placeholderData ?? [],
-            watchOptions: {
-                ...this.resolveOptions(watchOptions),
-                query: this.options.query
-            }
-        });
-    }
-    differentialWatch(differentialWatchOptions) {
-        return new DifferentialQueryProcessor({
-            db: this.options.db,
-            differentiator: differentialWatchOptions?.differentiator,
-            placeholderData: differentialWatchOptions?.placeholderData ?? [],
-            watchOptions: {
-                ...this.resolveOptions(differentialWatchOptions),
-                query: this.options.query
-            }
-        });
-    }
-}

package/lib/client/Query.d.ts

@@ -1,79 +0,0 @@
-import { ArrayComparator } from './watched/processors/comparators.js';
-import { DifferentialWatchedQuery, DifferentialWatchedQueryOptions } from './watched/processors/DifferentialQueryProcessor.js';
-import { ComparisonWatchedQuery } from './watched/processors/OnChangeQueryProcessor.js';
-import { WatchedQueryOptions } from './watched/WatchedQuery.js';
-/**
- * Query parameters for {@link ArrayQueryDefinition#parameters}
- */
-export type QueryParam = string | number | boolean | null | undefined | bigint | Uint8Array;
-/**
- * Options for building a query with {@link AbstractPowerSyncDatabase#query}.
- * This query will be executed with {@link AbstractPowerSyncDatabase#getAll}.
- */
-export interface ArrayQueryDefinition<RowType = unknown> {
-    sql: string;
-    parameters?: ReadonlyArray<Readonly<QueryParam>>;
-    /**
-     * Maps the raw SQLite row to a custom typed object.
-     * @example
-     * ```javascript
-     * mapper: (row) => ({
-     *  ...row,
-     *  created_at: new Date(row.created_at as string),
-     * })
-     * ```
-     */
-    mapper?: (row: Record<string, unknown>) => RowType;
-}
-/**
- * Options for {@link Query.watch}.
- */
-export interface StandardWatchedQueryOptions<RowType> extends WatchedQueryOptions {
-    /**
-     * Optional comparator which processes the items of an array of rows.
-     * The comparator compares the result set rows by index using the {@link ArrayComparatorOptions#compareBy} function.
-     * The comparator reports a changed result set as soon as a row does not match the previous result set.
-     *
-     * @example
-     * ```javascript
-     * comparator: new ArrayComparator({
-     *     compareBy: (item) => JSON.stringify(item)
-     * })
-     * ```
-     */
-    comparator?: ArrayComparator<RowType>;
-    /**
-     * The initial data state reported while the query is loading for the first time.
-     * @default []
-     */
-    placeholderData?: RowType[];
-}
-export interface Query<RowType> {
-    /**
-     * Creates a {@link WatchedQuery} which watches and emits results of the linked query.
-     *
-     * By default the returned watched query will emit changes whenever a change to the underlying SQLite tables is made.
-     * These changes might not be relevant to the query, but the query will emit a new result set.
-     *
-     * A {@link StandardWatchedQueryOptions#comparator} can be provided to limit the data emissions. The watched query will still
-     * query the underlying DB on underlying table changes, but the result will only be emitted if the comparator detects a change in the results.
-     *
-     * The comparator in this method is optimized and returns early as soon as it detects a change. Each data emission will correlate to a change in the result set,
-     * but note that the result set will not maintain internal object references to the previous result set. If internal object references are needed,
-     * consider using {@link Query#differentialWatch} instead.
-     */
-    watch(options?: StandardWatchedQueryOptions<RowType>): ComparisonWatchedQuery<ReadonlyArray<Readonly<RowType>>>;
-    /**
-     * Creates a {@link WatchedQuery} which watches and emits results of the linked query.
-     *
-     * This query method watches for changes in the underlying SQLite tables and runs the query on each table change.
-     * The difference between the current and previous result set is computed.
-     * The watched query will not emit changes if the result set is identical to the previous result set.
-     * If the result set is different, the watched query will emit the new result set and provide a detailed diff of the changes.
-     *
-     * The deep differentiation allows maintaining result set object references between result emissions.
-     * The {@link DifferentialWatchedQuery#state} `data` array will contain the previous row references for unchanged rows.
-     * A detailed diff of the changes can be accessed via {@link DifferentialWatchedQuery#state} `diff`.
-     */
-    differentialWatch(options?: DifferentialWatchedQueryOptions<RowType>): DifferentialWatchedQuery<RowType>;
-}

package/lib/client/Query.js

@@ -1 +0,0 @@
-export {};

package/lib/client/watched/GetAllQuery.d.ts

@@ -1,32 +0,0 @@
-import { CompiledQuery } from '../../types/types.js';
-import { AbstractPowerSyncDatabase } from '../AbstractPowerSyncDatabase.js';
-import { WatchCompatibleQuery } from './WatchedQuery.js';
-/**
- * Options for {@link GetAllQuery}.
- */
-export type GetAllQueryOptions<RowType = unknown> = {
-    sql: string;
-    parameters?: ReadonlyArray<unknown>;
-    /**
-     * Optional mapper function to convert raw rows into the desired RowType.
-     * @example
-     * ```javascript
-     * (rawRow) => ({
-     *   id: rawRow.id,
-     *   created_at: new Date(rawRow.created_at),
-     * })
-     * ```
-     */
-    mapper?: (rawRow: Record<string, unknown>) => RowType;
-};
-/**
- * Performs a {@link AbstractPowerSyncDatabase.getAll} operation for a watched query.
- */
-export declare class GetAllQuery<RowType = unknown> implements WatchCompatibleQuery<RowType[]> {
-    protected options: GetAllQueryOptions<RowType>;
-    constructor(options: GetAllQueryOptions<RowType>);
-    compile(): CompiledQuery;
-    execute(options: {
-        db: AbstractPowerSyncDatabase;
-    }): Promise<RowType[]>;
-}

package/lib/client/watched/GetAllQuery.js

@@ -1,24 +0,0 @@
-/**
- * Performs a {@link AbstractPowerSyncDatabase.getAll} operation for a watched query.
- */
-export class GetAllQuery {
-    options;
-    constructor(options) {
-        this.options = options;
-    }
-    compile() {
-        return {
-            sql: this.options.sql,
-            parameters: this.options.parameters ?? []
-        };
-    }
-    async execute(options) {
-        const { db } = options;
-        const { sql, parameters = [] } = this.compile();
-        const rawResult = await db.getAll(sql, [...parameters]);
-        if (this.options.mapper) {
-            return rawResult.map(this.options.mapper);
-        }
-        return rawResult;
-    }
-}

package/lib/client/watched/WatchedQuery.d.ts

@@ -1,93 +0,0 @@
-import { CompiledQuery } from '../../types/types.js';
-import { BaseListener } from '../../utils/BaseObserver.js';
-import { MetaBaseObserverInterface } from '../../utils/MetaBaseObserver.js';
-import { AbstractPowerSyncDatabase } from '../AbstractPowerSyncDatabase.js';
-/**
- * State for {@link WatchedQuery} instances.
- */
-export interface WatchedQueryState<Data> {
-    /**
-     * Indicates the initial loading state (hard loading).
-     * Loading becomes false once the first set of results from the watched query is available or an error occurs.
-     */
-    readonly isLoading: boolean;
-    /**
-     * Indicates whether the query is currently fetching data, is true during the initial load
-     * and any time when the query is re-evaluating (useful for large queries).
-     */
-    readonly isFetching: boolean;
-    /**
-     * The last error that occurred while executing the query.
-     */
-    readonly error: Error | null;
-    /**
-     * The last time the query was updated.
-     */
-    readonly lastUpdated: Date | null;
-    /**
-     * The last data returned by the query.
-     */
-    readonly data: Data;
-}
-/**
- * Options provided to the `execute` method of a {@link WatchCompatibleQuery}.
- */
-export interface WatchExecuteOptions {
-    sql: string;
-    parameters: any[];
-    db: AbstractPowerSyncDatabase;
-}
-/**
- * Similar to {@link CompatibleQuery}, except the `execute` method
- * does not enforce an Array result type.
- */
-export interface WatchCompatibleQuery<ResultType> {
-    execute(options: WatchExecuteOptions): Promise<ResultType>;
-    compile(): CompiledQuery;
-}
-export interface WatchedQueryOptions {
-    /** The minimum interval between queries. */
-    throttleMs?: number;
-    /**
-     * If true (default) the watched query will update its state to report
-     * on the fetching state of the query.
-     * Setting to false reduces the number of state changes if the fetch status
-     * is not relevant to the consumer.
-     */
-    reportFetching?: boolean;
-}
-export declare enum WatchedQueryListenerEvent {
-    ON_DATA = "onData",
-    ON_ERROR = "onError",
-    ON_STATE_CHANGE = "onStateChange",
-    CLOSED = "closed"
-}
-export interface WatchedQueryListener<Data> extends BaseListener {
-    [WatchedQueryListenerEvent.ON_DATA]?: (data: Data) => void | Promise<void>;
-    [WatchedQueryListenerEvent.ON_ERROR]?: (error: Error) => void | Promise<void>;
-    [WatchedQueryListenerEvent.ON_STATE_CHANGE]?: (state: WatchedQueryState<Data>) => void | Promise<void>;
-    [WatchedQueryListenerEvent.CLOSED]?: () => void | Promise<void>;
-}
-export declare const DEFAULT_WATCH_THROTTLE_MS = 30;
-export declare const DEFAULT_WATCH_QUERY_OPTIONS: WatchedQueryOptions;
-export interface WatchedQuery<Data = unknown, Settings extends WatchedQueryOptions = WatchedQueryOptions, Listener extends WatchedQueryListener<Data> = WatchedQueryListener<Data>> extends MetaBaseObserverInterface<Listener> {
-    /**
-     * Current state of the watched query.
-     */
-    readonly state: WatchedQueryState<Data>;
-    readonly closed: boolean;
-    /**
-     * Subscribe to watched query events.
-     * @returns A function to unsubscribe from the events.
-     */
-    registerListener(listener: Listener): () => void;
-    /**
-     * Updates the underlying query options.
-     * This will trigger a re-evaluation of the query and update the state.
-     */
-    updateSettings(options: Settings): Promise<void>;
-    /**
-     * Close the watched query and end all subscriptions.
-     */
-    close(): Promise<void>;
-}

package/lib/client/watched/WatchedQuery.js

@@ -1,12 +0,0 @@
-export var WatchedQueryListenerEvent;
-(function (WatchedQueryListenerEvent) {
-    WatchedQueryListenerEvent["ON_DATA"] = "onData";
-    WatchedQueryListenerEvent["ON_ERROR"] = "onError";
-    WatchedQueryListenerEvent["ON_STATE_CHANGE"] = "onStateChange";
-    WatchedQueryListenerEvent["CLOSED"] = "closed";
-})(WatchedQueryListenerEvent || (WatchedQueryListenerEvent = {}));
-export const DEFAULT_WATCH_THROTTLE_MS = 30;
-export const DEFAULT_WATCH_QUERY_OPTIONS = {
-    throttleMs: DEFAULT_WATCH_THROTTLE_MS,
-    reportFetching: true
-};

package/lib/client/watched/processors/AbstractQueryProcessor.d.ts

@@ -1,67 +0,0 @@
-import { AbstractPowerSyncDatabase } from '../../../client/AbstractPowerSyncDatabase.js';
-import { MetaBaseObserver } from '../../../utils/MetaBaseObserver.js';
-import { WatchedQuery, WatchedQueryListener, WatchedQueryOptions, WatchedQueryState } from '../WatchedQuery.js';
-/**
- * @internal
- */
-export interface AbstractQueryProcessorOptions<Data, Settings extends WatchedQueryOptions = WatchedQueryOptions> {
-    db: AbstractPowerSyncDatabase;
-    watchOptions: Settings;
-    placeholderData: Data;
-}
-/**
- * @internal
- */
-export interface LinkQueryOptions<Data, Settings extends WatchedQueryOptions = WatchedQueryOptions> {
-    abortSignal: AbortSignal;
-    settings: Settings;
-}
-type MutableDeep<T> = T extends ReadonlyArray<infer U> ? U[] : T;
-/**
- * @internal Mutable version of {@link WatchedQueryState}.
- * This is used internally to allow updates to the state.
- */
-export type MutableWatchedQueryState<Data> = {
-    -readonly [P in keyof WatchedQueryState<Data>]: MutableDeep<WatchedQueryState<Data>[P]>;
-};
-type WatchedQueryProcessorListener<Data> = WatchedQueryListener<Data>;
-/**
- * Performs underlying watching and yields a stream of results.
- * @internal
- */
-export declare abstract class AbstractQueryProcessor<Data = unknown[], Settings extends WatchedQueryOptions = WatchedQueryOptions> extends MetaBaseObserver<WatchedQueryProcessorListener<Data>> implements WatchedQuery<Data, Settings> {
-    protected options: AbstractQueryProcessorOptions<Data, Settings>;
-    readonly state: WatchedQueryState<Data>;
-    protected abortController: AbortController;
-    protected initialized: Promise<void>;
-    protected _closed: boolean;
-    protected disposeListeners: (() => void) | null;
-    get closed(): boolean;
-    constructor(options: AbstractQueryProcessorOptions<Data, Settings>);
-    protected constructInitialState(): WatchedQueryState<Data>;
-    protected get reportFetching(): boolean;
-    /**
-     * Updates the underlying query.
-     */
-    updateSettings(settings: Settings): Promise<void>;
-    /**
-     * This method is used to link a query to the subscribers of this listener class.
-     * This method should perform actual query watching and report results via {@link updateState} method.
-     */
-    protected abstract linkQuery(options: LinkQueryOptions<Data>): Promise<void>;
-    protected updateState(update: Partial<MutableWatchedQueryState<Data>>): Promise<void>;
-    /**
-     * Configures base DB listeners and links the query to listeners.
-     */
-    protected init(): Promise<void>;
-    close(): Promise<void>;
-    /**
-     * Runs a callback and reports errors to the error listeners.
-     */
-    protected runWithReporting<T>(callback: () => Promise<T>): Promise<void>;
-    /**
-     * Iterate listeners and reports errors to onError handlers.
-     */
-    protected iterateAsyncListenersWithError(callback: (listener: Partial<WatchedQueryProcessorListener<Data>>) => Promise<void> | void): Promise<void>;
-}
-export {};

package/lib/client/watched/processors/AbstractQueryProcessor.js

@@ -1,136 +0,0 @@
-import { MetaBaseObserver } from '../../../utils/MetaBaseObserver.js';
-/**
- * Performs underlying watching and yields a stream of results.
- * @internal
- */
-export class AbstractQueryProcessor extends MetaBaseObserver {
-    options;
-    state;
-    abortController;
-    initialized;
-    _closed;
-    disposeListeners;
-    get closed() {
-        return this._closed;
-    }
-    constructor(options) {
-        super();
-        this.options = options;
-        this.abortController = new AbortController();
-        this._closed = false;
-        this.state = this.constructInitialState();
-        this.disposeListeners = null;
-        this.initialized = this.init();
-    }
-    constructInitialState() {
-        return {
-            isLoading: true,
-            isFetching: this.reportFetching, // Only set to true if we will report updates in future
-            error: null,
-            lastUpdated: null,
-            data: this.options.placeholderData
-        };
-    }
-    get reportFetching() {
-        return this.options.watchOptions.reportFetching ?? true;
-    }
-    /**
-     * Updates the underlying query.
-     */
-    async updateSettings(settings) {
-        await this.initialized;
-        if (!this.state.isLoading) {
-            await this.updateState({
-                isLoading: true,
-                isFetching: this.reportFetching ? true : false
-            });
-        }
-        this.options.watchOptions = settings;
-        this.abortController.abort();
-        this.abortController = new AbortController();
-        await this.runWithReporting(() => this.linkQuery({
-            abortSignal: this.abortController.signal,
-            settings
-        }));
-    }
-    async updateState(update) {
-        if (typeof update.error !== 'undefined') {
-            await this.iterateAsyncListenersWithError(async (l) => l.onError?.(update.error));
-            // An error always stops for the current fetching state
-            update.isFetching = false;
-            update.isLoading = false;
-        }
-        Object.assign(this.state, { lastUpdated: new Date() }, update);
-        if (typeof update.data !== 'undefined') {
-            await this.iterateAsyncListenersWithError(async (l) => l.onData?.(this.state.data));
-        }
-        await this.iterateAsyncListenersWithError(async (l) => l.onStateChange?.(this.state));
-    }
-    /**
-     * Configures base DB listeners and links the query to listeners.
-     */
-    async init() {
-        const { db } = this.options;
-        const disposeCloseListener = db.registerListener({
-            closing: async () => {
-                await this.close();
-            }
-        });
-        // Wait for the schema to be set before listening to changes
-        await db.waitForReady();
-        const disposeSchemaListener = db.registerListener({
-            schemaChanged: async () => {
-                await this.runWithReporting(async () => {
-                    await this.updateSettings(this.options.watchOptions);
-                });
-            }
-        });
-        this.disposeListeners = () => {
-            disposeCloseListener();
-            disposeSchemaListener();
-        };
-        // Initial setup
-        this.runWithReporting(async () => {
-            await this.updateSettings(this.options.watchOptions);
-        });
-    }
-    async close() {
-        await this.initialized;
-        this.abortController.abort();
-        this.disposeListeners?.();
-        this.disposeListeners = null;
-        this._closed = true;
-        this.iterateListeners((l) => l.closed?.());
-        this.listeners.clear();
-    }
-    /**
-     * Runs a callback and reports errors to the error listeners.
-     */
-    async runWithReporting(callback) {
-        try {
-            await callback();
-        }
-        catch (error) {
-            // This will update the error on the state and iterate error listeners
-            await this.updateState({ error });
-        }
-    }
-    /**
-     * Iterate listeners and reports errors to onError handlers.
-     */
-    async iterateAsyncListenersWithError(callback) {
-        try {
-            await this.iterateAsyncListeners(async (l) => callback(l));
-        }
-        catch (error) {
-            try {
-                await this.iterateAsyncListeners(async (l) => l.onError?.(error));
-            }
-            catch (error) {
-                // Errors here are ignored
-                // since we are already in an error state
-                this.options.db.logger.error('Watched query error handler threw an Error', error);
-            }
-        }
-    }
-}