@powersync/common 0.0.0-dev-20250922105207 → 0.0.0-dev-20250922105508

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

@@ -1,5 +1,4 @@
 import Logger from 'js-logger';
-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';
@@ -7,6 +6,7 @@ import { throttleLeadingTrailing } from '../../../utils/async.js';
 import { PowerSyncControlCommand } from '../bucket/BucketStorageAdapter.js';
 import { SyncDataBucket } from '../bucket/SyncDataBucket.js';
 import { FetchStrategy } from './AbstractRemote.js';
+import { coreStatusToJs } from './core-instruction.js';
 import { isStreamingKeepalive, isStreamingSyncCheckpoint, isStreamingSyncCheckpointComplete, isStreamingSyncCheckpointDiff, isStreamingSyncCheckpointPartiallyComplete, isStreamingSyncData } from './streaming-sync-types.js';
 export var LockType;
 (function (LockType) {
@@ -72,7 +72,8 @@ export const DEFAULT_STREAM_CONNECTION_OPTIONS = {
     clientImplementation: DEFAULT_SYNC_CLIENT_IMPLEMENTATION,
     fetchStrategy: FetchStrategy.Buffered,
     params: {},
-    serializedSchema: undefined
+    serializedSchema: undefined,
+    includeDefaultStreams: true
 };
 // 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
@@ -89,13 +90,16 @@ export class AbstractStreamingSyncImplementation extends BaseObserver {
     crudUpdateListener;
     streamingSyncPromise;
     logger;
+    activeStreams;
     isUploadingCrud = false;
     notifyCompletedUploads;
+    handleActiveStreamsChange;
     syncStatus;
     triggerCrudUpload;
     constructor(options) {
         super();
-        this.options = { ...DEFAULT_STREAMING_SYNC_OPTIONS, ...options };
+        this.options = options;
+        this.activeStreams = options.subscriptions;
         this.logger = options.logger ?? Logger.get('PowerSyncStream');
         this.syncStatus = new SyncStatus({
             connected: false,
@@ -343,11 +347,12 @@ The next upload iteration will be delayed.`);
         while (true) {
             this.updateSyncStatus({ connecting: true });
             let shouldDelayRetry = true;
+            let result = null;
             try {
                 if (signal?.aborted) {
                     break;
                 }
-                await this.streamingSyncIteration(nestedAbortController.signal, options);
+                result = await this.streamingSyncIteration(nestedAbortController.signal, options);
                 // Continue immediately, streamingSyncIteration will wait before completing if necessary.
             }
             catch (ex) {
@@ -380,13 +385,15 @@ The next upload iteration will be delayed.`);
                     nestedAbortController.abort(new AbortOperation('Closing sync stream network requests before retry.'));
                     nestedAbortController = new AbortController();
                 }
-                this.updateSyncStatus({
-                    connected: false,
-                    connecting: true // May be unnecessary
-                });
-                // On error, wait a little before retrying
-                if (shouldDelayRetry) {
-                    await this.delayRetry(nestedAbortController.signal);
+                if (result?.immediateRestart != true) {
+                    this.updateSyncStatus({
+                        connected: false,
+                        connecting: true // May be unnecessary
+                    });
+                    // On error, wait a little before retrying
+                    if (shouldDelayRetry) {
+                        await this.delayRetry(nestedAbortController.signal);
+                    }
                 }
             }
         }
@@ -430,8 +437,8 @@ The next upload iteration will be delayed.`);
             return hasMigrated;
         }
     }
-    async streamingSyncIteration(signal, options) {
-        await this.obtainLock({
+    streamingSyncIteration(signal, options) {
+        return this.obtainLock({
             type: LockType.SYNC,
             signal,
             callback: async () => {
@@ -439,12 +446,15 @@ The next upload iteration will be delayed.`);
                     ...DEFAULT_STREAM_CONNECTION_OPTIONS,
                     ...(options ?? {})
                 };
-                if (resolvedOptions.clientImplementation == SyncClientImplementation.JAVASCRIPT) {
+                const clientImplementation = resolvedOptions.clientImplementation;
+                this.updateSyncStatus({ clientImplementation });
+                if (clientImplementation == SyncClientImplementation.JAVASCRIPT) {
                     await this.legacyStreamingSyncIteration(signal, resolvedOptions);
+                    return null;
                 }
                 else {
                     await this.requireKeyFormat(true);
-                    await this.rustSyncIteration(signal, resolvedOptions);
+                    return await this.rustSyncIteration(signal, resolvedOptions);
                 }
             }
         });
@@ -693,6 +703,10 @@ The next upload iteration will be delayed.`);
         const remote = this.options.remote;
         let receivingLines = null;
         let hadSyncLine = false;
+        let hideDisconnectOnRestart = false;
+        if (signal.aborted) {
+            throw new AbortOperation('Connection request has been aborted');
+        }
         const abortController = new AbortController();
         signal.addEventListener('abort', () => abortController.abort());
         // Pending sync lines received from the service, as well as local events that trigger a powersync_control
@@ -766,6 +780,8 @@ The next upload iteration will be delayed.`);
         }
         async function control(op, payload) {
             const rawResponse = await adapter.control(op, payload ?? null);
+            const logger = syncImplementation.logger;
+            logger.trace('powersync_control', op, payload == null || typeof payload == 'string' ? payload : '<bytes>', rawResponse);
             await handleInstructions(JSON.parse(rawResponse));
         }
         async function handleInstruction(instruction) {
@@ -783,27 +799,7 @@ The next upload iteration will be delayed.`);
                 }
             }
             else if ('UpdateSyncStatus' in instruction) {
-                function coreStatusToJs(status) {
-                    return {
-                        priority: status.priority,
-                        hasSynced: status.has_synced ?? undefined,
-                        lastSyncedAt: status?.last_synced_at != null ? new Date(status.last_synced_at * 1000) : undefined
-                    };
-                }
-                const info = instruction.UpdateSyncStatus.status;
-                const coreCompleteSync = info.priority_status.find((s) => s.priority == FULL_SYNC_PRIORITY);
-                const completeSync = coreCompleteSync != null ? coreStatusToJs(coreCompleteSync) : null;
-                syncImplementation.updateSyncStatus({
-                    connected: info.connected,
-                    connecting: info.connecting,
-                    dataFlow: {
-                        downloading: info.downloading != null,
-                        downloadProgress: info.downloading?.buckets
-                    },
-                    lastSyncedAt: completeSync?.lastSyncedAt,
-                    hasSynced: completeSync?.hasSynced,
-                    priorityStatusEntries: info.priority_status.map(coreStatusToJs)
-                });
+                syncImplementation.updateSyncStatus(coreStatusToJs(instruction.UpdateSyncStatus.status));
             }
             else if ('EstablishSyncStream' in instruction) {
                 if (receivingLines != null) {
@@ -828,6 +824,7 @@ The next upload iteration will be delayed.`);
             }
             else if ('CloseSyncStream' in instruction) {
                 abortController.abort();
+                hideDisconnectOnRestart = instruction.CloseSyncStream.hide_disconnect;
             }
             else if ('FlushFileSystem' in instruction) {
                 // Not necessary on JS platforms.
@@ -846,7 +843,11 @@ The next upload iteration will be delayed.`);
             }
         }
         try {
-            const options = { parameters: resolvedOptions.params };
+            const options = {
+                parameters: resolvedOptions.params,
+                active_streams: this.activeStreams,
+                include_defaults: resolvedOptions.includeDefaultStreams
+            };
             if (resolvedOptions.serializedSchema) {
                 options.schema = resolvedOptions.serializedSchema;
             }
@@ -856,12 +857,21 @@ The next upload iteration will be delayed.`);
                     controlInvocations.enqueueData({ command: PowerSyncControlCommand.NOTIFY_CRUD_UPLOAD_COMPLETED });
                 }
             };
+            this.handleActiveStreamsChange = () => {
+                if (controlInvocations && !controlInvocations?.closed) {
+                    controlInvocations.enqueueData({
+                        command: PowerSyncControlCommand.UPDATE_SUBSCRIPTIONS,
+                        payload: JSON.stringify(this.activeStreams)
+                    });
+                }
+            };
             await receivingLines;
         }
         finally {
-            this.notifyCompletedUploads = undefined;
+            this.notifyCompletedUploads = this.handleActiveStreamsChange = undefined;
             await stop();
         }
+        return { immediateRestart: hideDisconnectOnRestart };
     }
     async updateSyncStatusForStartingCheckpoint(checkpoint) {
         const localProgress = await this.options.adapter.getBucketOperationProgress();
@@ -934,7 +944,8 @@ The next upload iteration will be delayed.`);
                 ...this.syncStatus.dataFlowStatus,
                 ...options.dataFlow
             },
-            priorityStatusEntries: options.priorityStatusEntries ?? this.syncStatus.priorityStatusEntries
+            priorityStatusEntries: options.priorityStatusEntries ?? this.syncStatus.priorityStatusEntries,
+            clientImplementation: options.clientImplementation ?? this.syncStatus.clientImplementation
         });
         if (!this.syncStatus.isEqual(updatedStatus)) {
             this.syncStatus = updatedStatus;
@@ -965,4 +976,8 @@ The next upload iteration will be delayed.`);
             timeoutId = setTimeout(endDelay, retryDelayMs);
         });
     }
+    updateSubscriptions(subscriptions) {
+        this.activeStreams = subscriptions;
+        this.handleActiveStreamsChange?.();
+    }
 }

package/lib/client/sync/stream/core-instruction.d.ts

@@ -1,4 +1,5 @@
 import { StreamingSyncRequest } from './streaming-sync-types.js';
+import * as sync_status from '../../../db/crud/SyncStatus.js';
 /**
  * An internal instruction emitted by the sync client in the core extension in response to the JS
  * SDK passing sync data into the extension.
@@ -12,7 +13,9 @@ export type Instruction = {
 } | {
     FetchCredentials: FetchCredentials;
 } | {
-    CloseSyncStream: any;
+    CloseSyncStream: {
+        hide_disconnect: boolean;
+    };
 } | {
     FlushFileSystem: any;
 } | {
@@ -33,6 +36,21 @@ export interface CoreSyncStatus {
     connecting: boolean;
     priority_status: SyncPriorityStatus[];
     downloading: DownloadProgress | null;
+    streams: CoreStreamSubscription[];
+}
+export interface CoreStreamSubscription {
+    progress: {
+        total: number;
+        downloaded: number;
+    };
+    name: string;
+    parameters: any;
+    priority: number | null;
+    active: boolean;
+    is_default: boolean;
+    has_explicit_subscription: boolean;
+    expires_at: number | null;
+    last_synced_at: number | null;
 }
 export interface SyncPriorityStatus {
     priority: number;
@@ -51,3 +69,4 @@ export interface BucketProgress {
 export interface FetchCredentials {
     did_expire: boolean;
 }
+export declare function coreStatusToJs(status: CoreSyncStatus): sync_status.SyncStatusOptions;

package/lib/client/sync/stream/core-instruction.js

@@ -1 +1,26 @@
-export {};
+import { FULL_SYNC_PRIORITY } from '../../../db/crud/SyncProgress.js';
+function priorityToJs(status) {
+    return {
+        priority: status.priority,
+        hasSynced: status.has_synced ?? undefined,
+        lastSyncedAt: status.last_synced_at != null ? new Date(status.last_synced_at * 1000) : undefined
+    };
+}
+export function coreStatusToJs(status) {
+    const coreCompleteSync = status.priority_status.find((s) => s.priority == FULL_SYNC_PRIORITY);
+    const completeSync = coreCompleteSync != null ? priorityToJs(coreCompleteSync) : null;
+    return {
+        connected: status.connected,
+        connecting: status.connecting,
+        dataFlow: {
+            // We expose downloading as a boolean field, the core extension reports download information as a nullable
+            // download status. When that status is non-null, a download is in progress.
+            downloading: status.downloading != null,
+            downloadProgress: status.downloading?.buckets,
+            internalStreamSubscriptions: status.streams
+        },
+        lastSyncedAt: completeSync?.lastSyncedAt,
+        hasSynced: completeSync?.hasSynced,
+        priorityStatusEntries: status.priority_status.map(priorityToJs)
+    };
+}

package/lib/client/sync/sync-streams.d.ts

@@ -0,0 +1,98 @@
+/**
+ * A description of a sync stream, consisting of its {@link name} and the {@link parameters} used when subscribing.
+ */
+export interface SyncStreamDescription {
+    /**
+     * The name of the stream as it appears in the stream definition for the PowerSync service.
+     */
+    name: string;
+    /**
+     * The parameters used to subscribe to the stream, if any.
+     *
+     * The same stream can be subscribed to multiple times with different parameters.
+     */
+    parameters: Record<string, any> | null;
+}
+/**
+ * Information about a subscribed sync stream.
+ *
+ * This includes the {@link SyncStreamDescription}, along with information about the current sync status.
+ */
+export interface SyncSubscriptionDescription extends SyncStreamDescription {
+    active: boolean;
+    /**
+     * Whether this stream subscription is included by default, regardless of whether the stream has explicitly been
+     * subscribed to or not.
+     *
+     * It's possible for both {@link isDefault} and {@link hasExplicitSubscription} to be true at the same time - this
+     * happens when a default stream was subscribed explicitly.
+     */
+    isDefault: boolean;
+    /**
+     * Whether this stream has been subscribed to explicitly.
+     *
+     * It's possible for both {@link isDefault} and {@link hasExplicitSubscription} to be true at the same time - this
+     * happens when a default stream was subscribed explicitly.
+     */
+    hasExplicitSubscription: boolean;
+    /**
+     * For sync streams that have a time-to-live, the current time at which the stream would expire if not subscribed to
+     * again.
+     */
+    expiresAt: Date | null;
+    /**
+     * Whether this stream subscription has been synced at least once.
+     */
+    hasSynced: boolean;
+    /**
+     * If {@link hasSynced} is true, the last time data from this stream has been synced.
+     */
+    lastSyncedAt: Date | null;
+}
+export interface SyncStreamSubscribeOptions {
+    /**
+     * A "time to live" for this stream subscription, in seconds.
+     *
+     * The TTL control when a stream gets evicted after not having an active {@link SyncStreamSubscription} object
+     * attached to it.
+     */
+    ttl?: number;
+    /**
+     * A priority to assign to this subscription. This overrides the default priority that may have been set on streams.
+     *
+     * For details on priorities, see [priotized sync](https://docs.powersync.com/usage/use-case-examples/prioritized-sync).
+     */
+    priority?: 0 | 1 | 2 | 3;
+}
+/**
+ * A handle to a {@link SyncStreamDescription} that allows subscribing to the stream.
+ *
+ * To obtain an instance of {@link SyncStream}, call {@link AbstractPowerSyncDatabase.syncStream}.
+ */
+export interface SyncStream extends SyncStreamDescription {
+    /**
+     * Adds a subscription to this stream, requesting it to be included when connecting to the sync service.
+     *
+     * You should keep a reference to the returned {@link SyncStreamSubscription} object along as you need data for that
+     * stream. As soon as {@link SyncStreamSubscription.unsubscribe} is called for all subscriptions on this stream
+     * (including subscriptions created on other tabs), the {@link SyncStreamSubscribeOptions.ttl} starts ticking and will
+     * eventually evict the stream (unless {@link subscribe} is called again).
+     */
+    subscribe(options?: SyncStreamSubscribeOptions): Promise<SyncStreamSubscription>;
+    /**
+     * Clears all subscriptions attached to this stream and resets the TTL for the stream.
+     *
+     * This is a potentially dangerous operations, as it interferes with other stream subscriptions.
+     */
+    unsubscribeAll(): Promise<void>;
+}
+export interface SyncStreamSubscription extends SyncStreamDescription {
+    /**
+     * A promise that resolves once data from in this sync stream has been synced and applied.
+     */
+    waitForFirstSync(abort?: AbortSignal): Promise<void>;
+    /**
+     * Removes this stream subscription.
+     */
+    unsubscribe(): void;
+}

package/lib/client/sync/sync-streams.js

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

package/lib/client/triggers/TriggerManager.d.ts

@@ -323,7 +323,7 @@ export interface TriggerManager {
      *        },
      *        onChange: async (context) => {
      *          // Fetches the todo records that were inserted during this diff
-     *          const newTodos = await context.getAll<Database['todos']>(`
+     *          const newTodos = await context.withDiff<Database['todos']>(`
      *            SELECT
      *              todos.*
      *            FROM

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

@@ -65,12 +65,14 @@ export declare enum WatchedQueryListenerEvent {
     ON_DATA = "onData",
     ON_ERROR = "onError",
     ON_STATE_CHANGE = "onStateChange",
+    SETTINGS_WILL_UPDATE = "settingsWillUpdate",
     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.SETTINGS_WILL_UPDATE]?: () => void;
     [WatchedQueryListenerEvent.CLOSED]?: () => void | Promise<void>;
 }
 export declare const DEFAULT_WATCH_THROTTLE_MS = 30;

package/lib/client/watched/WatchedQuery.js

@@ -3,6 +3,7 @@ export var WatchedQueryListenerEvent;
     WatchedQueryListenerEvent["ON_DATA"] = "onData";
     WatchedQueryListenerEvent["ON_ERROR"] = "onError";
     WatchedQueryListenerEvent["ON_STATE_CHANGE"] = "onStateChange";
+    WatchedQueryListenerEvent["SETTINGS_WILL_UPDATE"] = "settingsWillUpdate";
     WatchedQueryListenerEvent["CLOSED"] = "closed";
 })(WatchedQueryListenerEvent || (WatchedQueryListenerEvent = {}));
 export const DEFAULT_WATCH_THROTTLE_MS = 30;

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

@@ -40,6 +40,7 @@ export declare abstract class AbstractQueryProcessor<Data = unknown[], Settings
     constructor(options: AbstractQueryProcessorOptions<Data, Settings>);
     protected constructInitialState(): WatchedQueryState<Data>;
     protected get reportFetching(): boolean;
+    protected updateSettingsInternal(settings: Settings, signal: AbortSignal): Promise<void>;
     /**
      * Updates the underlying query.
      */
@@ -53,7 +54,7 @@ export declare abstract class AbstractQueryProcessor<Data = unknown[], Settings
     /**
      * Configures base DB listeners and links the query to listeners.
      */
-    protected init(): Promise<void>;
+    protected init(signal: AbortSignal): Promise<void>;
     close(): Promise<void>;
     /**
      * Runs a callback and reports errors to the error listeners.

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

@@ -1,4 +1,5 @@
 import { MetaBaseObserver } from '../../../utils/MetaBaseObserver.js';
+import { WatchedQueryListenerEvent } from '../WatchedQuery.js';
 /**
  * Performs underlying watching and yields a stream of results.
  * @internal
@@ -20,7 +21,7 @@ export class AbstractQueryProcessor extends MetaBaseObserver {
         this._closed = false;
         this.state = this.constructInitialState();
         this.disposeListeners = null;
-        this.initialized = this.init();
+        this.initialized = this.init(this.abortController.signal);
     }
     constructInitialState() {
         return {
@@ -34,25 +35,40 @@ export class AbstractQueryProcessor extends MetaBaseObserver {
     get reportFetching() {
         return this.options.watchOptions.reportFetching ?? true;
     }
-    /**
-     * Updates the underlying query.
-     */
-    async updateSettings(settings) {
-        await this.initialized;
+    async updateSettingsInternal(settings, signal) {
+        // This may have been aborted while awaiting or if multiple calls to `updateSettings` were made
+        if (this._closed || signal.aborted) {
+            return;
+        }
+        this.options.watchOptions = settings;
+        this.iterateListeners((l) => l[WatchedQueryListenerEvent.SETTINGS_WILL_UPDATE]?.());
         if (!this.state.isFetching && this.reportFetching) {
             await this.updateState({
                 isFetching: true
             });
         }
-        this.options.watchOptions = settings;
-        this.abortController.abort();
-        this.abortController = new AbortController();
         await this.runWithReporting(() => this.linkQuery({
-            abortSignal: this.abortController.signal,
+            abortSignal: signal,
             settings
         }));
     }
+    /**
+     * Updates the underlying query.
+     */
+    async updateSettings(settings) {
+        // Abort the previous request
+        this.abortController.abort();
+        // Keep track of this controller's abort status
+        const abortController = new AbortController();
+        // Allow this to be aborted externally
+        this.abortController = abortController;
+        await this.initialized;
+        return this.updateSettingsInternal(settings, abortController.signal);
+    }
     async updateState(update) {
+        if (this._closed) {
+            return;
+        }
         if (typeof update.error !== 'undefined') {
             await this.iterateAsyncListenersWithError(async (l) => l.onError?.(update.error));
             // An error always stops for the current fetching state
@@ -68,7 +84,7 @@ export class AbstractQueryProcessor extends MetaBaseObserver {
     /**
      * Configures base DB listeners and links the query to listeners.
      */
-    async init() {
+    async init(signal) {
         const { db } = this.options;
         const disposeCloseListener = db.registerListener({
             closing: async () => {
@@ -89,16 +105,15 @@ export class AbstractQueryProcessor extends MetaBaseObserver {
             disposeSchemaListener();
         };
         // Initial setup
-        this.runWithReporting(async () => {
-            await this.updateSettings(this.options.watchOptions);
+        await this.runWithReporting(async () => {
+            await this.updateSettingsInternal(this.options.watchOptions, signal);
         });
     }
     async close() {
-        await this.initialized;
+        this._closed = true;
         this.abortController.abort();
         this.disposeListeners?.();
         this.disposeListeners = null;
-        this._closed = true;
         this.iterateListeners((l) => l.closed?.());
         this.listeners.clear();
     }

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

@@ -113,7 +113,7 @@ export class DifferentialQueryProcessor extends AbstractQueryProcessor {
         });
         db.onChangeWithCallback({
             onChange: async () => {
-                if (this.closed) {
+                if (this.closed || abortSignal.aborted) {
                     return;
                 }
                 // This fires for each change of the relevant tables
@@ -130,6 +130,9 @@ export class DifferentialQueryProcessor extends AbstractQueryProcessor {
                         parameters: [...compiledQuery.parameters],
                         db: this.options.db
                     });
+                    if (abortSignal.aborted) {
+                        return;
+                    }
                     if (this.reportFetching) {
                         partialStateUpdate.isFetching = false;
                     }
@@ -145,6 +148,9 @@ export class DifferentialQueryProcessor extends AbstractQueryProcessor {
                             data: diff.all
                         });
                     }
+                    if (this.state.error) {
+                        partialStateUpdate.error = null;
+                    }
                     if (Object.keys(partialStateUpdate).length > 0) {
                         await this.updateState(partialStateUpdate);
                     }

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

@@ -26,7 +26,7 @@ export class OnChangeQueryProcessor extends AbstractQueryProcessor {
         });
         db.onChangeWithCallback({
             onChange: async () => {
-                if (this.closed) {
+                if (this.closed || abortSignal.aborted) {
                     return;
                 }
                 // This fires for each change of the relevant tables
@@ -43,6 +43,9 @@ export class OnChangeQueryProcessor extends AbstractQueryProcessor {
                         parameters: [...compiledQuery.parameters],
                         db: this.options.db
                     });
+                    if (abortSignal.aborted) {
+                        return;
+                    }
                     if (this.reportFetching) {
                         partialStateUpdate.isFetching = false;
                     }
@@ -55,6 +58,9 @@ export class OnChangeQueryProcessor extends AbstractQueryProcessor {
                             data: result
                         });
                     }
+                    if (this.state.error) {
+                        partialStateUpdate.error = null;
+                    }
                     if (Object.keys(partialStateUpdate).length > 0) {
                         await this.updateState(partialStateUpdate);
                     }

package/lib/db/crud/SyncStatus.d.ts

@@ -1,4 +1,7 @@
-import { InternalProgressInformation, SyncProgress } from './SyncProgress.js';
+import { CoreStreamSubscription } from '../../client/sync/stream/core-instruction.js';
+import { SyncClientImplementation } from '../../client/sync/stream/AbstractStreamingSyncImplementation.js';
+import { InternalProgressInformation, ProgressWithOperations, SyncProgress } from './SyncProgress.js';
+import { SyncStreamDescription, SyncSubscriptionDescription } from '../../client/sync/sync-streams.js';
 export type SyncDataFlowStatus = Partial<{
     downloading: boolean;
     uploading: boolean;
@@ -19,6 +22,7 @@ export type SyncDataFlowStatus = Partial<{
      * Please use the {@link SyncStatus#downloadProgress} property to track sync progress.
      */
     downloadProgress: InternalProgressInformation | null;
+    internalStreamSubscriptions: CoreStreamSubscription[] | null;
 }>;
 export interface SyncPriorityStatus {
     priority: number;
@@ -32,10 +36,18 @@ export type SyncStatusOptions = {
     lastSyncedAt?: Date;
     hasSynced?: boolean;
     priorityStatusEntries?: SyncPriorityStatus[];
+    clientImplementation?: SyncClientImplementation;
 };
 export declare class SyncStatus {
     protected options: SyncStatusOptions;
     constructor(options: SyncStatusOptions);
+    /**
+     * Returns the used sync client implementation (either the one implemented in JavaScript or the newer Rust-based
+     * implementation).
+     *
+     * This information is only available after a connection has been requested.
+     */
+    get clientImplementation(): SyncClientImplementation | undefined;
     /**
      * Indicates if the client is currently connected to the PowerSync service.
      *
@@ -90,7 +102,23 @@ export declare class SyncStatus {
          * Please use the {@link SyncStatus#downloadProgress} property to track sync progress.
          */
         downloadProgress: InternalProgressInformation | null;
+        internalStreamSubscriptions: CoreStreamSubscription[] | null;
     }>;
+    /**
+     * All sync streams currently being tracked in teh database.
+     *
+     * This returns null when the database is currently being opened and we don't have reliable information about all
+     * included streams yet.
+     *
+     * @experimental Sync streams are currently in alpha.
+     */
+    get syncStreams(): SyncStreamStatus[] | undefined;
+    /**
+     * If the `stream` appears in {@link syncStreams}, returns the current status for that stream.
+     *
+     * @experimental Sync streams are currently in alpha.
+     */
+    forStream(stream: SyncStreamDescription): SyncStreamStatus | undefined;
     /**
      * Provides sync status information for all bucket priorities, sorted by priority (highest first).
      *
@@ -148,3 +176,11 @@ export declare class SyncStatus {
     toJSON(): SyncStatusOptions;
     private static comparePriorities;
 }
+/**
+ * Information about a sync stream subscription.
+ */
+export interface SyncStreamStatus {
+    progress: ProgressWithOperations | null;
+    subscription: SyncSubscriptionDescription;
+    priority: number | null;
+}