@powersync/common 0.0.0-dev-20250526133243 → 0.0.0-dev-20250528152729

package/lib/client/AbstractPowerSyncDatabase.d.ts

@@ -5,6 +5,7 @@ import { SyncStatus } from '../db/crud/SyncStatus.js';
 import { UploadQueueStats } from '../db/crud/UploadQueueStatus.js';
 import { Schema } from '../db/schema/Schema.js';
 import { BaseObserver } from '../utils/BaseObserver.js';
+import { ConnectionManager } from './ConnectionManager.js';
 import { SQLOpenFactory, SQLOpenOptions } from './SQLOpenFactory.js';
 import { PowerSyncBackendConnector } from './connection/PowerSyncBackendConnector.js';
 import { BucketStorageAdapter } from './sync/bucket/BucketStorageAdapter.js';
@@ -79,10 +80,6 @@ export interface PowerSyncCloseOptions {
      */
     disconnect?: boolean;
 }
-type StoredConnectionOptions = {
-    connector: PowerSyncBackendConnector;
-    options: PowerSyncConnectionOptions;
-};
 export declare const DEFAULT_POWERSYNC_CLOSE_OPTIONS: PowerSyncCloseOptions;
 export declare const DEFAULT_WATCH_THROTTLE_MS = 30;
 export declare const DEFAULT_POWERSYNC_DB_OPTIONS: {
@@ -118,35 +115,13 @@ export declare abstract class AbstractPowerSyncDatabase extends BaseObserver<Pow
      * Current connection status.
      */
     currentStatus: SyncStatus;
-    syncStreamImplementation?: StreamingSyncImplementation;
     sdkVersion: string;
     protected bucketStorageAdapter: BucketStorageAdapter;
-    private syncStatusListenerDisposer?;
     protected _isReadyPromise: Promise<void>;
+    protected connectionManager: ConnectionManager;
+    get syncStreamImplementation(): StreamingSyncImplementation | null;
     protected _schema: Schema;
     private _database;
-    /**
-     * Tracks active connection attempts
-     */
-    protected connectingPromise: Promise<void> | null;
-    /**
-     * Tracks actively instantiating a streaming sync implementation.
-     */
-    protected syncStreamInitPromise: Promise<void> | null;
-    /**
-     * Active disconnect operation. Calling disconnect multiple times
-     * will resolve to the same operation.
-     */
-    protected disconnectingPromise: Promise<void> | null;
-    /**
-     * Tracks the last parameters supplied to `connect` calls.
-     * Calling `connect` multiple times in succession will result in:
-     * - 1 pending connection operation which will be aborted.
-     * - updating the last set of parameters while waiting for the pending
-     *   attempt to be aborted
-     * - internally connecting with the last set of parameters
-     */
-    protected pendingConnectionOptions: StoredConnectionOptions | null;
     protected connectionMutex: Mutex;
     constructor(options: PowerSyncDatabaseOptionsWithDBAdapter);
     constructor(options: PowerSyncDatabaseOptionsWithOpenFactory);
@@ -222,7 +197,6 @@ export declare abstract class AbstractPowerSyncDatabase extends BaseObserver<Pow
      * Locking here is mostly only important on web for multiple tab scenarios.
      */
     protected runExclusive<T>(callback: () => Promise<T>): Promise<T>;
-    protected connectInternal(): Promise<void>;
     /**
      * Connects to stream of events from the PowerSync instance.
      */
@@ -233,8 +207,6 @@ export declare abstract class AbstractPowerSyncDatabase extends BaseObserver<Pow
      * Use {@link connect} to connect again.
      */
     disconnect(): Promise<void>;
-    protected disconnectInternal(): Promise<void>;
-    protected performDisconnect(): Promise<void>;
     /**
      *  Disconnect and clear the database.
      *  Use this when logging out.
@@ -519,4 +491,3 @@ export declare abstract class AbstractPowerSyncDatabase extends BaseObserver<Pow
      */
     private executeReadOnly;
 }
-export {};

package/lib/client/AbstractPowerSyncDatabase.js

@@ -9,6 +9,7 @@ import { BaseObserver } from '../utils/BaseObserver.js';
 import { ControlledExecutor } from '../utils/ControlledExecutor.js';
 import { throttleTrailing } from '../utils/async.js';
 import { mutexRunExclusive } from '../utils/mutex.js';
+import { ConnectionManager } from './ConnectionManager.js';
 import { isDBAdapter, isSQLOpenFactory, isSQLOpenOptions } from './SQLOpenFactory.js';
 import { runOnSchemaChange } from './runOnSchemaChange.js';
 import { PSInternalTable } from './sync/bucket/BucketStorageAdapter.js';
@@ -59,35 +60,15 @@ export class AbstractPowerSyncDatabase extends BaseObserver {
      * Current connection status.
      */
     currentStatus;
-    syncStreamImplementation;
     sdkVersion;
     bucketStorageAdapter;
-    syncStatusListenerDisposer;
     _isReadyPromise;
+    connectionManager;
+    get syncStreamImplementation() {
+        return this.connectionManager.syncStreamImplementation;
+    }
     _schema;
     _database;
-    /**
-     * Tracks active connection attempts
-     */
-    connectingPromise;
-    /**
-     * Tracks actively instantiating a streaming sync implementation.
-     */
-    syncStreamInitPromise;
-    /**
-     * Active disconnect operation. Calling disconnect multiple times
-     * will resolve to the same operation.
-     */
-    disconnectingPromise;
-    /**
-     * Tracks the last parameters supplied to `connect` calls.
-     * Calling `connect` multiple times in succession will result in:
-     * - 1 pending connection operation which will be aborted.
-     * - updating the last set of parameters while waiting for the pending
-     *   attempt to be aborted
-     * - internally connecting with the last set of parameters
-     */
-    pendingConnectionOptions;
     connectionMutex;
     constructor(options) {
         super();
@@ -115,11 +96,31 @@ export class AbstractPowerSyncDatabase extends BaseObserver {
         this._schema = schema;
         this.ready = false;
         this.sdkVersion = '';
-        this.connectingPromise = null;
-        this.syncStreamInitPromise = null;
-        this.pendingConnectionOptions = null;
         this.connectionMutex = new Mutex();
         // Start async init
+        this.connectionManager = new ConnectionManager({
+            createSyncImplementation: async (connector, options) => {
+                await this.waitForReady();
+                return this.runExclusive(async () => {
+                    const sync = this.generateSyncStreamImplementation(connector, this.resolvedConnectionOptions(options));
+                    const onDispose = sync.registerListener({
+                        statusChanged: (status) => {
+                            this.currentStatus = new SyncStatus({
+                                ...status.toJSON(),
+                                hasSynced: this.currentStatus?.hasSynced || !!status.lastSyncedAt
+                            });
+                            this.iterateListeners((cb) => cb.statusChanged?.(this.currentStatus));
+                        }
+                    });
+                    await sync.waitForReady();
+                    return {
+                        sync,
+                        onDispose
+                    };
+                });
+            },
+            logger: this.logger
+        });
         this._isReadyPromise = this.initialize();
     }
     /**
@@ -299,93 +300,11 @@ export class AbstractPowerSyncDatabase extends BaseObserver {
     runExclusive(callback) {
         return this.connectionMutex.runExclusive(callback);
     }
-    async connectInternal() {
-        let appliedOptions = null;
-        // This method ensures a disconnect before any connection attempt
-        await this.disconnectInternal();
-        /**
-         * This portion creates a sync implementation which can be racy when disconnecting or
-         * if multiple tabs on web are in use.
-         * This is protected in an exclusive lock.
-         * The promise tracks the creation which is used to synchronize disconnect attempts.
-         */
-        this.syncStreamInitPromise = this.runExclusive(async () => {
-            if (this.closed) {
-                throw new Error('Cannot connect using a closed client');
-            }
-            // Always await this if present since we will be populating a new sync implementation shortly
-            await this.disconnectingPromise;
-            if (!this.pendingConnectionOptions) {
-                // A disconnect could have cleared this.
-                return;
-            }
-            // get pending options and clear it in order for other connect attempts to queue other options
-            const { connector, options } = this.pendingConnectionOptions;
-            appliedOptions = options;
-            this.pendingConnectionOptions = null;
-            this.syncStreamImplementation = this.generateSyncStreamImplementation(connector, this.resolvedConnectionOptions(options));
-            this.syncStatusListenerDisposer = this.syncStreamImplementation.registerListener({
-                statusChanged: (status) => {
-                    this.currentStatus = new SyncStatus({
-                        ...status.toJSON(),
-                        hasSynced: this.currentStatus?.hasSynced || !!status.lastSyncedAt
-                    });
-                    this.iterateListeners((cb) => cb.statusChanged?.(this.currentStatus));
-                }
-            });
-            await this.syncStreamImplementation.waitForReady();
-        });
-        await this.syncStreamInitPromise;
-        this.syncStreamInitPromise = null;
-        if (!appliedOptions) {
-            // A disconnect could have cleared the options which did not create a syncStreamImplementation
-            return;
-        }
-        // It might be possible that a disconnect triggered between the last check
-        // and this point. Awaiting here allows the sync stream to be cleared if disconnected.
-        await this.disconnectingPromise;
-        this.syncStreamImplementation?.triggerCrudUpload();
-        this.options.logger?.debug('Attempting to connect to PowerSync instance');
-        await this.syncStreamImplementation?.connect(appliedOptions);
-    }
     /**
      * Connects to stream of events from the PowerSync instance.
      */
     async connect(connector, options) {
-        // Keep track if there were pending operations before this call
-        const hadPendingOptions = !!this.pendingConnectionOptions;
-        // Update pending options to the latest values
-        this.pendingConnectionOptions = {
-            connector,
-            options: options ?? {}
-        };
-        await this.waitForReady();
-        // Disconnecting here provides aborting in progress connection attempts.
-        // The connectInternal method will clear pending options once it starts connecting (with the options).
-        // We only need to trigger a disconnect here if we have already reached the point of connecting.
-        // If we do already have pending options, a disconnect has already been performed.
-        // The connectInternal method also does a sanity disconnect to prevent straggler connections.
-        if (!hadPendingOptions) {
-            await this.disconnectInternal();
-        }
-        // Triggers a connect which checks if pending options are available after the connect completes.
-        // The completion can be for a successful, unsuccessful or aborted connection attempt.
-        // If pending options are available another connection will be triggered.
-        const checkConnection = async () => {
-            if (this.pendingConnectionOptions) {
-                // Pending options have been placed while connecting.
-                // Need to reconnect.
-                this.connectingPromise = this.connectInternal().finally(checkConnection);
-                return this.connectingPromise;
-            }
-            else {
-                // Clear the connecting promise, done.
-                this.connectingPromise = null;
-                return;
-            }
-        };
-        this.connectingPromise ??= this.connectInternal().finally(checkConnection);
-        return this.connectingPromise;
+        return this.connectionManager.connect(connector, options);
     }
     /**
      * Close the sync connection.
@@ -393,28 +312,7 @@ export class AbstractPowerSyncDatabase extends BaseObserver {
      * Use {@link connect} to connect again.
      */
     async disconnect() {
-        await this.waitForReady();
-        // This will help abort pending connects
-        this.pendingConnectionOptions = null;
-        await this.disconnectInternal();
-    }
-    async disconnectInternal() {
-        if (this.disconnectingPromise) {
-            // A disconnect is already in progress
-            return this.disconnectingPromise;
-        }
-        // Wait if a sync stream implementation is being created before closing it
-        // (syncStreamImplementation must be assigned before we can properly dispose it)
-        await this.syncStreamInitPromise;
-        this.disconnectingPromise = this.performDisconnect();
-        await this.disconnectingPromise;
-        this.disconnectingPromise = null;
-    }
-    async performDisconnect() {
-        await this.syncStreamImplementation?.disconnect();
-        this.syncStatusListenerDisposer?.();
-        await this.syncStreamImplementation?.dispose();
-        this.syncStreamImplementation = undefined;
+        return this.connectionManager.disconnect();
     }
     /**
      *  Disconnect and clear the database.
@@ -453,7 +351,7 @@ export class AbstractPowerSyncDatabase extends BaseObserver {
         if (disconnect) {
             await this.disconnect();
         }
-        await this.syncStreamImplementation?.dispose();
+        await this.connectionManager.close();
         await this.database.close();
         this.closed = true;
     }

package/lib/client/ConnectionManager.d.ts

@@ -0,0 +1,72 @@
+import { ILogger } from 'js-logger';
+import { BaseListener, BaseObserver } from '../utils/BaseObserver.js';
+import { PowerSyncBackendConnector } from './connection/PowerSyncBackendConnector.js';
+import { PowerSyncConnectionOptions, StreamingSyncImplementation } from './sync/stream/AbstractStreamingSyncImplementation.js';
+/**
+ * @internal
+ */
+export interface ConnectionManagerSyncImplementationResult {
+    sync: StreamingSyncImplementation;
+    onDispose: () => Promise<void> | void;
+}
+/**
+ * @internal
+ */
+export interface ConnectionManagerOptions {
+    createSyncImplementation(connector: PowerSyncBackendConnector, options: PowerSyncConnectionOptions): Promise<ConnectionManagerSyncImplementationResult>;
+    logger: ILogger;
+}
+type StoredConnectionOptions = {
+    connector: PowerSyncBackendConnector;
+    options: PowerSyncConnectionOptions;
+};
+/**
+ * @internal
+ */
+export interface ConnectionManagerListener extends BaseListener {
+    syncStreamCreated: (sync: StreamingSyncImplementation) => void;
+}
+/**
+ * @internal
+ */
+export declare class ConnectionManager extends BaseObserver<ConnectionManagerListener> {
+    protected options: ConnectionManagerOptions;
+    /**
+     * Tracks active connection attempts
+     */
+    protected connectingPromise: Promise<void> | null;
+    /**
+     * Tracks actively instantiating a streaming sync implementation.
+     */
+    protected syncStreamInitPromise: Promise<void> | null;
+    /**
+     * Active disconnect operation. Calling disconnect multiple times
+     * will resolve to the same operation.
+     */
+    protected disconnectingPromise: Promise<void> | null;
+    /**
+     * Tracks the last parameters supplied to `connect` calls.
+     * Calling `connect` multiple times in succession will result in:
+     * - 1 pending connection operation which will be aborted.
+     * - updating the last set of parameters while waiting for the pending
+     *   attempt to be aborted
+     * - internally connecting with the last set of parameters
+     */
+    protected pendingConnectionOptions: StoredConnectionOptions | null;
+    syncStreamImplementation: StreamingSyncImplementation | null;
+    syncDisposer: (() => Promise<void> | void) | null;
+    constructor(options: ConnectionManagerOptions);
+    get logger(): ILogger;
+    close(): Promise<void>;
+    connect(connector: PowerSyncBackendConnector, options?: PowerSyncConnectionOptions): Promise<void>;
+    protected connectInternal(): Promise<void>;
+    /**
+     * Close the sync connection.
+     *
+     * Use {@link connect} to connect again.
+     */
+    disconnect(): Promise<void>;
+    protected disconnectInternal(): Promise<void>;
+    protected performDisconnect(): Promise<void>;
+}
+export {};

package/lib/client/ConnectionManager.js

@@ -0,0 +1,161 @@
+import { BaseObserver } from '../utils/BaseObserver.js';
+/**
+ * @internal
+ */
+export class ConnectionManager extends BaseObserver {
+    options;
+    /**
+     * Tracks active connection attempts
+     */
+    connectingPromise;
+    /**
+     * Tracks actively instantiating a streaming sync implementation.
+     */
+    syncStreamInitPromise;
+    /**
+     * Active disconnect operation. Calling disconnect multiple times
+     * will resolve to the same operation.
+     */
+    disconnectingPromise;
+    /**
+     * Tracks the last parameters supplied to `connect` calls.
+     * Calling `connect` multiple times in succession will result in:
+     * - 1 pending connection operation which will be aborted.
+     * - updating the last set of parameters while waiting for the pending
+     *   attempt to be aborted
+     * - internally connecting with the last set of parameters
+     */
+    pendingConnectionOptions;
+    syncStreamImplementation;
+    syncDisposer;
+    constructor(options) {
+        super();
+        this.options = options;
+        this.connectingPromise = null;
+        this.syncStreamInitPromise = null;
+        this.disconnectingPromise = null;
+        this.pendingConnectionOptions = null;
+        this.syncStreamImplementation = null;
+        this.syncDisposer = null;
+    }
+    get logger() {
+        return this.options.logger;
+    }
+    async close() {
+        await this.syncDisposer?.();
+    }
+    async connect(connector, options) {
+        // Keep track if there were pending operations before this call
+        const hadPendingOptions = !!this.pendingConnectionOptions;
+        // Update pending options to the latest values
+        this.pendingConnectionOptions = {
+            connector,
+            options: options ?? {}
+        };
+        // Disconnecting here provides aborting in progress connection attempts.
+        // The connectInternal method will clear pending options once it starts connecting (with the options).
+        // We only need to trigger a disconnect here if we have already reached the point of connecting.
+        // If we do already have pending options, a disconnect has already been performed.
+        // The connectInternal method also does a sanity disconnect to prevent straggler connections.
+        // We should also disconnect if we have already completed a connection attempt.
+        if (!hadPendingOptions) {
+            await this.disconnectInternal();
+        }
+        // Triggers a connect which checks if pending options are available after the connect completes.
+        // The completion can be for a successful, unsuccessful or aborted connection attempt.
+        // If pending options are available another connection will be triggered.
+        const checkConnection = async () => {
+            if (this.pendingConnectionOptions) {
+                // Pending options have been placed while connecting.
+                // Need to reconnect.
+                this.connectingPromise = this.connectInternal().finally(checkConnection);
+                return this.connectingPromise;
+            }
+            else {
+                // Clear the connecting promise, done.
+                this.connectingPromise = null;
+                return;
+            }
+        };
+        this.connectingPromise ??= this.connectInternal().finally(checkConnection);
+        return this.connectingPromise;
+    }
+    async connectInternal() {
+        let appliedOptions = null;
+        // This method ensures a disconnect before any connection attempt
+        await this.disconnectInternal();
+        /**
+         * This portion creates a sync implementation which can be racy when disconnecting or
+         * if multiple tabs on web are in use.
+         * This is protected in an exclusive lock.
+         * The promise tracks the creation which is used to synchronize disconnect attempts.
+         */
+        this.syncStreamInitPromise = new Promise(async (resolve, reject) => {
+            try {
+                if (!this.pendingConnectionOptions) {
+                    this.logger.debug('No pending connection options found, not creating sync stream implementation');
+                    // A disconnect could have cleared this.
+                    return;
+                }
+                const { connector, options } = this.pendingConnectionOptions;
+                appliedOptions = options;
+                this.pendingConnectionOptions = null;
+                const { sync, onDispose } = await this.options.createSyncImplementation(connector, options);
+                this.iterateListeners((l) => l.syncStreamCreated?.(sync));
+                this.syncStreamImplementation = sync;
+                this.syncDisposer = onDispose;
+                await this.syncStreamImplementation.waitForReady();
+                resolve();
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+        await this.syncStreamInitPromise;
+        this.syncStreamInitPromise = null;
+        if (!appliedOptions) {
+            // A disconnect could have cleared the options which did not create a syncStreamImplementation
+            return;
+        }
+        // It might be possible that a disconnect triggered between the last check
+        // and this point. Awaiting here allows the sync stream to be cleared if disconnected.
+        await this.disconnectingPromise;
+        this.logger.debug('Attempting to connect to PowerSync instance');
+        await this.syncStreamImplementation?.connect(appliedOptions);
+        this.syncStreamImplementation?.triggerCrudUpload();
+    }
+    /**
+     * Close the sync connection.
+     *
+     * Use {@link connect} to connect again.
+     */
+    async disconnect() {
+        // This will help abort pending connects
+        this.pendingConnectionOptions = null;
+        await this.disconnectInternal();
+    }
+    async disconnectInternal() {
+        if (this.disconnectingPromise) {
+            // A disconnect is already in progress
+            return this.disconnectingPromise;
+        }
+        // Wait if a sync stream implementation is being created before closing it
+        // (syncStreamImplementation must be assigned before we can properly dispose it)
+        await this.syncStreamInitPromise;
+        this.disconnectingPromise = this.performDisconnect();
+        await this.disconnectingPromise;
+        this.disconnectingPromise = null;
+    }
+    async performDisconnect() {
+        // Keep reference to the sync stream implementation and disposer
+        // The class members will be cleared before we trigger the disconnect
+        // to prevent any further calls to the sync stream implementation.
+        const sync = this.syncStreamImplementation;
+        this.syncStreamImplementation = null;
+        const disposer = this.syncDisposer;
+        this.syncDisposer = null;
+        await sync?.disconnect();
+        await sync?.dispose();
+        await disposer?.();
+    }
+}

package/lib/index.d.ts

@@ -1,35 +1,34 @@
 export * from './client/AbstractPowerSyncDatabase.js';
 export * from './client/AbstractPowerSyncOpenFactory.js';
-export * from './client/SQLOpenFactory.js';
+export { compilableQueryWatch, CompilableQueryWatchHandler } from './client/compilableQueryWatch.js';
 export * from './client/connection/PowerSyncBackendConnector.js';
 export * from './client/connection/PowerSyncCredentials.js';
-export * from './client/sync/bucket/BucketStorageAdapter.js';
+export { MAX_OP_ID } from './client/constants.js';
 export { runOnSchemaChange } from './client/runOnSchemaChange.js';
-export { CompilableQueryWatchHandler, compilableQueryWatch } from './client/compilableQueryWatch.js';
-export { UpdateType, CrudEntry, OpId } from './client/sync/bucket/CrudEntry.js';
-export * from './client/sync/bucket/SqliteBucketStorage.js';
+export * from './client/SQLOpenFactory.js';
+export * from './client/sync/bucket/BucketStorageAdapter.js';
 export * from './client/sync/bucket/CrudBatch.js';
+export { CrudEntry, OpId, UpdateType } from './client/sync/bucket/CrudEntry.js';
 export * from './client/sync/bucket/CrudTransaction.js';
+export * from './client/sync/bucket/OplogEntry.js';
+export * from './client/sync/bucket/OpType.js';
+export * from './client/sync/bucket/SqliteBucketStorage.js';
 export * from './client/sync/bucket/SyncDataBatch.js';
 export * from './client/sync/bucket/SyncDataBucket.js';
-export * from './client/sync/bucket/OpType.js';
-export * from './client/sync/bucket/OplogEntry.js';
 export * from './client/sync/stream/AbstractRemote.js';
 export * from './client/sync/stream/AbstractStreamingSyncImplementation.js';
 export * from './client/sync/stream/streaming-sync-types.js';
-export { MAX_OP_ID } from './client/constants.js';
+export * from './client/ConnectionManager.js';
 export { ProgressWithOperations, SyncProgress } from './db/crud/SyncProgress.js';
 export * from './db/crud/SyncStatus.js';
 export * from './db/crud/UploadQueueStatus.js';
-export * from './db/schema/Schema.js';
-export * from './db/schema/Table.js';
+export * from './db/DBAdapter.js';
+export * from './db/schema/Column.js';
 export * from './db/schema/Index.js';
 export * from './db/schema/IndexedColumn.js';
-export * from './db/schema/Column.js';
+export * from './db/schema/Schema.js';
+export * from './db/schema/Table.js';
 export * from './db/schema/TableV2.js';
-export * from './db/crud/SyncStatus.js';
-export * from './db/crud/UploadQueueStatus.js';
-export * from './db/DBAdapter.js';
 export * from './utils/AbortOperation.js';
 export * from './utils/BaseObserver.js';
 export * from './utils/DataStream.js';

package/lib/index.js

@@ -1,35 +1,34 @@
 export * from './client/AbstractPowerSyncDatabase.js';
 export * from './client/AbstractPowerSyncOpenFactory.js';
-export * from './client/SQLOpenFactory.js';
+export { compilableQueryWatch } from './client/compilableQueryWatch.js';
 export * from './client/connection/PowerSyncBackendConnector.js';
 export * from './client/connection/PowerSyncCredentials.js';
-export * from './client/sync/bucket/BucketStorageAdapter.js';
+export { MAX_OP_ID } from './client/constants.js';
 export { runOnSchemaChange } from './client/runOnSchemaChange.js';
-export { compilableQueryWatch } from './client/compilableQueryWatch.js';
-export { UpdateType, CrudEntry } from './client/sync/bucket/CrudEntry.js';
-export * from './client/sync/bucket/SqliteBucketStorage.js';
+export * from './client/SQLOpenFactory.js';
+export * from './client/sync/bucket/BucketStorageAdapter.js';
 export * from './client/sync/bucket/CrudBatch.js';
+export { CrudEntry, UpdateType } from './client/sync/bucket/CrudEntry.js';
 export * from './client/sync/bucket/CrudTransaction.js';
+export * from './client/sync/bucket/OplogEntry.js';
+export * from './client/sync/bucket/OpType.js';
+export * from './client/sync/bucket/SqliteBucketStorage.js';
 export * from './client/sync/bucket/SyncDataBatch.js';
 export * from './client/sync/bucket/SyncDataBucket.js';
-export * from './client/sync/bucket/OpType.js';
-export * from './client/sync/bucket/OplogEntry.js';
 export * from './client/sync/stream/AbstractRemote.js';
 export * from './client/sync/stream/AbstractStreamingSyncImplementation.js';
 export * from './client/sync/stream/streaming-sync-types.js';
-export { MAX_OP_ID } from './client/constants.js';
+export * from './client/ConnectionManager.js';
 export { SyncProgress } from './db/crud/SyncProgress.js';
 export * from './db/crud/SyncStatus.js';
 export * from './db/crud/UploadQueueStatus.js';
-export * from './db/schema/Schema.js';
-export * from './db/schema/Table.js';
+export * from './db/DBAdapter.js';
+export * from './db/schema/Column.js';
 export * from './db/schema/Index.js';
 export * from './db/schema/IndexedColumn.js';
-export * from './db/schema/Column.js';
+export * from './db/schema/Schema.js';
+export * from './db/schema/Table.js';
 export * from './db/schema/TableV2.js';
-export * from './db/crud/SyncStatus.js';
-export * from './db/crud/UploadQueueStatus.js';
-export * from './db/DBAdapter.js';
 export * from './utils/AbortOperation.js';
 export * from './utils/BaseObserver.js';
 export * from './utils/DataStream.js';

package/package.json

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