@powersync/web 2.2.0 → 2.3.1

package/src/worker/sync/AbstractSharedSyncClientProvider.ts

@@ -8,6 +8,7 @@ export abstract class AbstractSharedSyncClientProvider {
   abstract fetchCredentials(): Promise<PowerSyncCredentials | null>;
   abstract invalidateCredentials(): void;
   abstract uploadCrud(): Promise<void>;
+  abstract postCheckpointRequest(clientId: string, requestId: string): Promise<string | null>;
   abstract statusChanged(status: SyncStatusJson): void;
   abstract getDBWorkerPort(): Promise<MessagePort>;
 

package/src/worker/sync/SharedSyncImplementation.ts

@@ -60,7 +60,7 @@ export type ManualSharedSyncPayload = {
 export type SharedSyncInitOptions = {
   streamOptions: Omit<
     WebStreamingSyncImplementationOptions,
-    'adapter' | 'uploadCrud' | 'remote' | 'subscriptions' | 'logger'
+    'adapter' | 'uploadCrud' | 'postCheckpointRequest' | 'remote' | 'subscriptions' | 'logger'
   >;
   dbParams: ResolvedWebSQLOpenOptions;
   enableBroadcastLogs: boolean;
@@ -85,14 +85,6 @@ export type WrappedSyncPort = {
   isClosing: boolean;
 };
 
-/**
- * @internal
- */
-export type RemoteOperationAbortController = {
-  controller: AbortController;
-  activePort: WrappedSyncPort;
-};
-
 /**
  * HACK: The shared implementation wraps and provides its own
  * PowerSyncBackendConnector when generating the streaming sync implementation.
@@ -110,9 +102,6 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
   protected isInitialized: Promise<void>;
   protected statusListener?: () => void;
 
-  protected fetchCredentialsController?: RemoteOperationAbortController;
-  protected uploadDataController?: RemoteOperationAbortController;
-
   protected syncParams: SharedSyncInitOptions | null;
   protected lastConnectOptions: ResolvedSyncOptions | undefined;
   protected portMutex: Mutex;
@@ -334,18 +323,6 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
       // Remove from the list of active ports
       this.ports.splice(index, 1);
 
-      /**
-       * The port might currently be in use. Any active functions might
-       * not resolve. Abort them here.
-       */
-      [this.fetchCredentialsController, this.uploadDataController].forEach((abortController) => {
-        if (abortController?.activePort == port) {
-          abortController!.controller.abort(
-            new AbortOperation('Closing pending requests after client port is removed')
-          );
-        }
-      });
-
       // Close the worker wrapped database connection, we can't accurately rely on this connection
       for (const closeListener of trackedPort.closeListeners) {
         await closeListener();
@@ -363,10 +340,8 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
     });
   }
 
-  async getWriteCheckpoint(): Promise<string> {
-    return this.withSyncImplementation(async (sync) => {
-      return sync.getWriteCheckpoint();
-    });
+  requestCheckpoint() {
+    return this.withSyncImplementation((sync) => sync.requestCheckpoint());
   }
 
   protected async withSyncImplementation<T>(callback: (sync: StreamingSyncImplementation) => Promise<T>): Promise<T> {
@@ -411,58 +386,27 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
               this.logger.log({ level: LogLevels.error, message: 'error invalidating credentials', error });
             }
           },
-          fetchCredentials: async () => {
-            const lastPort = await this.getLastWrappedPort();
-            if (!lastPort) {
-              throw new Error('No client port found to fetch credentials');
-            }
-            return new Promise(async (resolve, reject) => {
-              const abortController = new AbortController();
-              this.fetchCredentialsController = {
-                controller: abortController,
-                activePort: lastPort
-              };
-
-              abortController.signal.onabort = reject;
-              try {
-                this.logger.log({
-                  level: LogLevels.info,
-                  message: 'calling the last port client provider for credentials'
-                });
-                resolve(await lastPort.clientProvider.fetchCredentials());
-              } catch (ex) {
-                reject(ex);
-              } finally {
-                this.fetchCredentialsController = undefined;
-              }
-            });
+          fetchCredentials: () => {
+            return this.#useConnector((port) => {
+              this.logger.log({
+                level: LogLevels.info,
+                message: 'calling the last port client provider for credentials'
+              });
+
+              return port.clientProvider.fetchCredentials();
+            }, 'fetchCredentials');
           }
         },
         this.logger
       ),
-      uploadCrud: async () => {
-        const lastPort = await this.getLastWrappedPort();
-        if (!lastPort) {
-          throw new Error('No client port found to upload crud');
-        }
-
-        return new Promise(async (resolve, reject) => {
-          const abortController = new AbortController();
-          this.uploadDataController = {
-            controller: abortController,
-            activePort: lastPort
-          };
-
-          // Resolving will make it retry
-          abortController.signal.onabort = () => resolve();
-          try {
-            resolve(await lastPort.clientProvider.uploadCrud());
-          } catch (ex) {
-            reject(ex);
-          } finally {
-            this.uploadDataController = undefined;
-          }
-        });
+      uploadCrud: () => {
+        return this.#useConnector((port) => port.clientProvider.uploadCrud(), 'uploadCrud');
+      },
+      postCheckpointRequest: (clientId, requestId) => {
+        return this.#useConnector(
+          (port) => port.clientProvider.postCheckpointRequest(clientId, requestId),
+          'postCheckpointRequest'
+        );
       },
       ...syncParams.streamOptions,
       subscriptions: this.subscriptions,
@@ -471,6 +415,27 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
     });
   }
 
+  async #useConnector<T>(inner: (port: WrappedSyncPort) => Promise<T>, debugContext: string): Promise<T> {
+    const lastPort = await this.getLastWrappedPort();
+    if (!lastPort) {
+      throw new Error(`No client port found for ${debugContext}`);
+    }
+
+    return new Promise((resolve, reject) => {
+      function portClosed() {
+        reject(new Error(`Tab closed while handling ${debugContext}`));
+      }
+
+      lastPort.closeListeners.push(portClosed);
+
+      inner(lastPort)
+        .then(resolve, reject)
+        .finally(() => {
+          lastPort.closeListeners.splice(lastPort.closeListeners.indexOf(portClosed), 1);
+        });
+    });
+  }
+
   /**
    * Requests a random client to share its database connection with us.
    */

package/src/worker/sync/WorkerClient.ts

@@ -78,10 +78,6 @@ export class WorkerClient {
     return this.sync.setParams(params);
   }
 
-  getWriteCheckpoint() {
-    return this.sync.getWriteCheckpoint();
-  }
-
   connect(options: ResolvedSyncOptions, schema: any) {
     return this.sync.connect(options, schema);
   }
@@ -92,6 +88,10 @@ export class WorkerClient {
     }
   }
 
+  requestCheckpoint(): Promise<bigint> {
+    return this.sync.requestCheckpoint();
+  }
+
   disconnect() {
     return this.sync.disconnect();
   }