@powersync/common 1.33.2 → 1.35.0

package/lib/client/sync/stream/AbstractStreamingSyncImplementation.js

@@ -1,9 +1,9 @@
 import Logger from 'js-logger';
-import { SyncStatus } from '../../../db/crud/SyncStatus.js';
 import { FULL_SYNC_PRIORITY } from '../../../db/crud/SyncProgress.js';
+import { SyncStatus } from '../../../db/crud/SyncStatus.js';
 import { AbortOperation } from '../../../utils/AbortOperation.js';
 import { BaseObserver } from '../../../utils/BaseObserver.js';
-import { onAbortPromise, throttleLeadingTrailing } from '../../../utils/async.js';
+import { throttleLeadingTrailing } from '../../../utils/async.js';
 import { PowerSyncControlCommand } from '../bucket/BucketStorageAdapter.js';
 import { SyncDataBucket } from '../bucket/SyncDataBucket.js';
 import { FetchStrategy } from './AbstractRemote.js';
@@ -65,14 +65,14 @@ export const DEFAULT_CRUD_UPLOAD_THROTTLE_MS = 1000;
 export const DEFAULT_RETRY_DELAY_MS = 5000;
 export const DEFAULT_STREAMING_SYNC_OPTIONS = {
     retryDelayMs: DEFAULT_RETRY_DELAY_MS,
-    logger: Logger.get('PowerSyncStream'),
     crudUploadThrottleMs: DEFAULT_CRUD_UPLOAD_THROTTLE_MS
 };
 export const DEFAULT_STREAM_CONNECTION_OPTIONS = {
     connectionMethod: SyncStreamConnectionMethod.WEB_SOCKET,
     clientImplementation: DEFAULT_SYNC_CLIENT_IMPLEMENTATION,
     fetchStrategy: FetchStrategy.Buffered,
-    params: {}
+    params: {},
+    serializedSchema: undefined
 };
 // The priority we assume when we receive checkpoint lines where no priority is set.
 // This is the default priority used by the sync service, but can be set to an arbitrary
@@ -83,15 +83,20 @@ export class AbstractStreamingSyncImplementation extends BaseObserver {
     _lastSyncedAt;
     options;
     abortController;
+    // In rare cases, mostly for tests, uploads can be triggered without being properly connected.
+    // This allows ensuring that all upload processes can be aborted.
+    uploadAbortController;
     crudUpdateListener;
     streamingSyncPromise;
-    pendingCrudUpload;
+    logger;
+    isUploadingCrud = false;
     notifyCompletedUploads;
     syncStatus;
     triggerCrudUpload;
     constructor(options) {
         super();
         this.options = { ...DEFAULT_STREAMING_SYNC_OPTIONS, ...options };
+        this.logger = options.logger ?? Logger.get('PowerSyncStream');
         this.syncStatus = new SyncStatus({
             connected: false,
             connecting: false,
@@ -103,15 +108,13 @@ export class AbstractStreamingSyncImplementation extends BaseObserver {
         });
         this.abortController = null;
         this.triggerCrudUpload = throttleLeadingTrailing(() => {
-            if (!this.syncStatus.connected || this.pendingCrudUpload != null) {
+            if (!this.syncStatus.connected || this.isUploadingCrud) {
                 return;
             }
-            this.pendingCrudUpload = new Promise((resolve) => {
-                this._uploadAllCrud().finally(() => {
-                    this.notifyCompletedUploads?.();
-                    this.pendingCrudUpload = undefined;
-                    resolve();
-                });
+            this.isUploadingCrud = true;
+            this._uploadAllCrud().finally(() => {
+                this.notifyCompletedUploads?.();
+                this.isUploadingCrud = false;
             });
         }, this.options.crudUploadThrottleMs);
     }
@@ -157,12 +160,11 @@ export class AbstractStreamingSyncImplementation extends BaseObserver {
     get isConnected() {
         return this.syncStatus.connected;
     }
-    get logger() {
-        return this.options.logger;
-    }
     async dispose() {
+        super.dispose();
         this.crudUpdateListener?.();
         this.crudUpdateListener = undefined;
+        this.uploadAbortController?.abort();
     }
     async hasCompletedSync() {
         return this.options.adapter.hasCompletedSync();
@@ -171,7 +173,9 @@ export class AbstractStreamingSyncImplementation extends BaseObserver {
         const clientId = await this.options.adapter.getClientId();
         let path = `/write-checkpoint2.json?client_id=${clientId}`;
         const response = await this.options.remote.get(path);
-        return response['data']['write_checkpoint'];
+        const checkpoint = response['data']['write_checkpoint'];
+        this.logger.debug(`Created write checkpoint: ${checkpoint}`);
+        return checkpoint;
     }
     async _uploadAllCrud() {
         return this.obtainLock({
@@ -181,7 +185,12 @@ export class AbstractStreamingSyncImplementation extends BaseObserver {
                  * Keep track of the first item in the CRUD queue for the last `uploadCrud` iteration.
                  */
                 let checkedCrudItem;
-                while (true) {
+                const controller = new AbortController();
+                this.uploadAbortController = controller;
+                this.abortController?.signal.addEventListener('abort', () => {
+                    controller.abort();
+                }, { once: true });
+                while (!controller.signal.aborted) {
                     try {
                         /**
                          * This is the first item in the FIFO CRUD queue.
@@ -210,7 +219,11 @@ The next upload iteration will be delayed.`);
                         }
                         else {
                             // Uploading is completed
-                            await this.options.adapter.updateLocalTarget(() => this.getWriteCheckpoint());
+                            const neededUpdate = await this.options.adapter.updateLocalTarget(() => this.getWriteCheckpoint());
+                            if (neededUpdate == false && checkedCrudItem != null) {
+                                // Only log this if there was something to upload
+                                this.logger.debug('Upload complete, no write checkpoint needed.');
+                            }
                             break;
                         }
                     }
@@ -222,7 +235,7 @@ The next upload iteration will be delayed.`);
                                 uploadError: ex
                             }
                         });
-                        await this.delayRetry();
+                        await this.delayRetry(controller.signal);
                         if (!this.isConnected) {
                             // Exit the upload loop if the sync stream is no longer connected
                             break;
@@ -237,6 +250,7 @@ The next upload iteration will be delayed.`);
                         });
                     }
                 }
+                this.uploadAbortController = null;
             }
         });
     }
@@ -361,6 +375,7 @@ The next upload iteration will be delayed.`);
                 });
             }
             finally {
+                this.notifyCompletedUploads = undefined;
                 if (!signal.aborted) {
                     nestedAbortController.abort(new AbortOperation('Closing sync stream network requests before retry.'));
                     nestedAbortController = new AbortController();
@@ -435,13 +450,16 @@ The next upload iteration will be delayed.`);
         });
     }
     async legacyStreamingSyncIteration(signal, resolvedOptions) {
+        const rawTables = resolvedOptions.serializedSchema?.raw_tables;
+        if (rawTables != null && rawTables.length) {
+            this.logger.warn('Raw tables require the Rust-based sync client. The JS client will ignore them.');
+        }
         this.logger.debug('Streaming sync iteration started');
         this.options.adapter.startSession();
         let [req, bucketMap] = await this.collectLocalBucketState();
-        // These are compared by reference
         let targetCheckpoint = null;
-        let validatedCheckpoint = null;
-        let appliedCheckpoint = null;
+        // A checkpoint that has been validated but not applied (e.g. due to pending local writes)
+        let pendingValidatedCheckpoint = null;
         const clientId = await this.options.adapter.getClientId();
         const usingFixedKeyFormat = await this.requireKeyFormat(false);
         this.logger.debug('Requesting stream from server');
@@ -458,21 +476,55 @@ The next upload iteration will be delayed.`);
         };
         let stream;
         if (resolvedOptions?.connectionMethod == SyncStreamConnectionMethod.HTTP) {
-            stream = await this.options.remote.postStream(syncOptions);
+            stream = await this.options.remote.postStreamRaw(syncOptions, (line) => {
+                if (typeof line == 'string') {
+                    return JSON.parse(line);
+                }
+                else {
+                    // Directly enqueued by us
+                    return line;
+                }
+            });
         }
         else {
-            stream = await this.options.remote.socketStream({
+            const bson = await this.options.remote.getBSON();
+            stream = await this.options.remote.socketStreamRaw({
                 ...syncOptions,
                 ...{ fetchStrategy: resolvedOptions.fetchStrategy }
-            });
+            }, (payload) => {
+                if (payload instanceof Uint8Array) {
+                    return bson.deserialize(payload);
+                }
+                else {
+                    // Directly enqueued by us
+                    return payload;
+                }
+            }, bson);
         }
         this.logger.debug('Stream established. Processing events');
+        this.notifyCompletedUploads = () => {
+            if (!stream.closed) {
+                stream.enqueueData({ crud_upload_completed: null });
+            }
+        };
         while (!stream.closed) {
             const line = await stream.read();
             if (!line) {
                 // The stream has closed while waiting
                 return;
             }
+            if ('crud_upload_completed' in line) {
+                if (pendingValidatedCheckpoint != null) {
+                    const { applied, endIteration } = await this.applyCheckpoint(pendingValidatedCheckpoint);
+                    if (applied) {
+                        pendingValidatedCheckpoint = null;
+                    }
+                    else if (endIteration) {
+                        break;
+                    }
+                }
+                continue;
+            }
             // A connection is active and messages are being received
             if (!this.syncStatus.connected) {
                 // There is a connection now
@@ -483,6 +535,8 @@ The next upload iteration will be delayed.`);
             }
             if (isStreamingSyncCheckpoint(line)) {
                 targetCheckpoint = line.checkpoint;
+                // New checkpoint - existing validated checkpoint is no longer valid
+                pendingValidatedCheckpoint = null;
                 const bucketsToDelete = new Set(bucketMap.keys());
                 const newBuckets = new Map();
                 for (const checksum of line.checkpoint.buckets) {
@@ -501,14 +555,20 @@ The next upload iteration will be delayed.`);
                 await this.updateSyncStatusForStartingCheckpoint(targetCheckpoint);
             }
             else if (isStreamingSyncCheckpointComplete(line)) {
-                const result = await this.applyCheckpoint(targetCheckpoint, signal);
+                const result = await this.applyCheckpoint(targetCheckpoint);
                 if (result.endIteration) {
                     return;
                 }
-                else if (result.applied) {
-                    appliedCheckpoint = targetCheckpoint;
+                else if (!result.applied) {
+                    // "Could not apply checkpoint due to local data". We need to retry after
+                    // finishing uploads.
+                    pendingValidatedCheckpoint = targetCheckpoint;
+                }
+                else {
+                    // Nothing to retry later. This would likely already be null from the last
+                    // checksum or checksum_diff operation, but we make sure.
+                    pendingValidatedCheckpoint = null;
                 }
-                validatedCheckpoint = targetCheckpoint;
             }
             else if (isStreamingSyncCheckpointPartiallyComplete(line)) {
                 const priority = line.partial_checkpoint_complete.priority;
@@ -545,6 +605,8 @@ The next upload iteration will be delayed.`);
                 if (targetCheckpoint == null) {
                     throw new Error('Checkpoint diff without previous checkpoint');
                 }
+                // New checkpoint - existing validated checkpoint is no longer valid
+                pendingValidatedCheckpoint = null;
                 const diff = line.checkpoint_diff;
                 const newBuckets = new Map();
                 for (const checksum of targetCheckpoint.buckets) {
@@ -618,26 +680,7 @@ The next upload iteration will be delayed.`);
                 this.triggerCrudUpload();
             }
             else {
-                this.logger.debug('Sync complete');
-                if (targetCheckpoint === appliedCheckpoint) {
-                    this.updateSyncStatus({
-                        connected: true,
-                        lastSyncedAt: new Date(),
-                        priorityStatusEntries: [],
-                        dataFlow: {
-                            downloadError: undefined
-                        }
-                    });
-                }
-                else if (validatedCheckpoint === targetCheckpoint) {
-                    const result = await this.applyCheckpoint(targetCheckpoint, signal);
-                    if (result.endIteration) {
-                        return;
-                    }
-                    else if (result.applied) {
-                        appliedCheckpoint = targetCheckpoint;
-                    }
-                }
+                this.logger.debug('Received unknown sync line', line);
             }
         }
         this.logger.debug('Stream input empty');
@@ -803,9 +846,11 @@ The next upload iteration will be delayed.`);
             }
         }
         try {
-            await control(PowerSyncControlCommand.START, JSON.stringify({
-                parameters: resolvedOptions.params
-            }));
+            const options = { parameters: resolvedOptions.params };
+            if (resolvedOptions.serializedSchema) {
+                options.schema = resolvedOptions.serializedSchema;
+            }
+            await control(PowerSyncControlCommand.START, JSON.stringify(options));
             this.notifyCompletedUploads = () => {
                 controlInvocations?.enqueueData({ command: PowerSyncControlCommand.NOTIFY_CRUD_UPLOAD_COMPLETED });
             };
@@ -853,45 +898,30 @@ The next upload iteration will be delayed.`);
             }
         });
     }
-    async applyCheckpoint(checkpoint, abort) {
+    async applyCheckpoint(checkpoint) {
         let result = await this.options.adapter.syncLocalDatabase(checkpoint);
-        const pending = this.pendingCrudUpload;
         if (!result.checkpointValid) {
-            this.logger.debug('Checksum mismatch in checkpoint, will reconnect');
+            this.logger.debug(`Checksum mismatch in checkpoint ${checkpoint.last_op_id}, will reconnect`);
             // This means checksums failed. Start again with a new checkpoint.
             // TODO: better back-off
             await new Promise((resolve) => setTimeout(resolve, 50));
             return { applied: false, endIteration: true };
         }
-        else if (!result.ready && pending != null) {
-            // We have pending entries in the local upload queue or are waiting to confirm a write
-            // checkpoint, which prevented this checkpoint from applying. Wait for that to complete and
-            // try again.
-            this.logger.debug('Could not apply checkpoint due to local data. Waiting for in-progress upload before retrying.');
-            await Promise.race([pending, onAbortPromise(abort)]);
-            if (abort.aborted) {
-                return { applied: false, endIteration: true };
-            }
-            // Try again now that uploads have completed.
-            result = await this.options.adapter.syncLocalDatabase(checkpoint);
-        }
-        if (result.checkpointValid && result.ready) {
-            this.logger.debug('validated checkpoint', checkpoint);
-            this.updateSyncStatus({
-                connected: true,
-                lastSyncedAt: new Date(),
-                dataFlow: {
-                    downloading: false,
-                    downloadProgress: null,
-                    downloadError: undefined
-                }
-            });
-            return { applied: true, endIteration: false };
-        }
-        else {
-            this.logger.debug('Could not apply checkpoint. Waiting for next sync complete line.');
+        else if (!result.ready) {
+            this.logger.debug(`Could not apply checkpoint ${checkpoint.last_op_id} due to local data. We will retry applying the checkpoint after that upload is completed.`);
             return { applied: false, endIteration: false };
         }
+        this.logger.debug(`Applied checkpoint ${checkpoint.last_op_id}`, checkpoint);
+        this.updateSyncStatus({
+            connected: true,
+            lastSyncedAt: new Date(),
+            dataFlow: {
+                downloading: false,
+                downloadProgress: null,
+                downloadError: undefined
+            }
+        });
+        return { applied: true, endIteration: false };
     }
     updateSyncStatus(options) {
         const updatedStatus = new SyncStatus({

package/lib/client/sync/stream/streaming-sync-types.d.ts

@@ -101,6 +101,10 @@ export interface StreamingSyncKeepalive {
     token_expires_in: number;
 }
 export type StreamingSyncLine = StreamingSyncDataJSON | StreamingSyncCheckpoint | StreamingSyncCheckpointDiff | StreamingSyncCheckpointComplete | StreamingSyncCheckpointPartiallyComplete | StreamingSyncKeepalive;
+export type CrudUploadNotification = {
+    crud_upload_completed: null;
+};
+export type StreamingSyncLineOrCrudUploadComplete = StreamingSyncLine | CrudUploadNotification;
 export interface BucketRequest {
     name: string;
     /**

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

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,24 @@
+/**
+ * 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

@@ -0,0 +1,98 @@
+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;
+    /**
+     * By default, watched queries requery the database on any change to any dependent table of the query.
+     * Supplying an override here can be used to limit the tables which trigger querying the database.
+     */
+    triggerOnTables?: string[];
+}
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,67 @@
+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 {};