cleanup

Author: stevensJourney

packages/common/src/client/AbstractPowerSyncDatabase.ts

@@ -459,7 +459,7 @@ export abstract class AbstractPowerSyncDatabase extends BaseObserver<PowerSyncDB
   /**
    * Locking mechagnism for exclusively running critical portions of connect/disconnect operations.
    */
-  protected abstract connectExclusive(callback: () => Promise<void>): Promise<void>;
+  protected abstract runExclusive<T>(callback: () => Promise<T>): Promise<T>;
 
   protected async connectInternal() {
     await this.disconnectInternal();
@@ -472,7 +472,7 @@ export abstract class AbstractPowerSyncDatabase extends BaseObserver<PowerSyncDB
      * This is protected in an exclusive lock.
      * The promise tracks the creation which is used to synchronize disconnect attempts.
      */
-    this.syncStreamInitPromise = this.connectExclusive(async () => {
+    this.syncStreamInitPromise = this.runExclusive(async () => {
       if (this.closed) {
         throw new Error('Cannot connect using a closed client');
       }

packages/node/src/db/PowerSyncDatabase.ts

@@ -56,11 +56,11 @@ export type NodePowerSyncConnectionOptions = PowerSyncConnectionOptions & NodeAd
  * ```
  */
 export class PowerSyncDatabase extends AbstractPowerSyncDatabase {
-  protected connectionLock: Lock;
+  protected lock: Lock;
 
   constructor(options: NodePowerSyncDatabaseOptions) {
     super(options);
-    this.connectionLock = new Lock();
+    this.lock = new Lock();
   }
 
   async _initialize(): Promise<void> {
@@ -85,8 +85,8 @@ export class PowerSyncDatabase extends AbstractPowerSyncDatabase {
     return super.connect(connector, options);
   }
 
-  protected async connectExclusive(callback: () => Promise<void>): Promise<void> {
-    await this.connectionLock.acquire(`connection-lock-${this.database.name}`, callback);
+  protected async runExclusive<T>(callback: () => Promise<T>): Promise<T> {
+    return await this.lock.acquire(`lock-${this.database.name}`, callback);
   }
 
   protected generateSyncStreamImplementation(

packages/react-native/src/db/PowerSyncDatabase.ts

@@ -28,7 +28,7 @@ import { ReactNativeQuickSqliteOpenFactory } from './adapters/react-native-quick
  * ```
  */
 export class PowerSyncDatabase extends AbstractPowerSyncDatabase {
-  protected connectionLock = new Lock();
+  protected lock = new Lock();
 
   async _initialize(): Promise<void> {}
 
@@ -45,8 +45,8 @@ export class PowerSyncDatabase extends AbstractPowerSyncDatabase {
     return new SqliteBucketStorage(this.database, AbstractPowerSyncDatabase.transactionMutex);
   }
 
-  protected async connectExclusive(callback: () => Promise<void>): Promise<void> {
-    await this.connectionLock.acquire(`connection-lock-${this.database.name}`, callback);
+  protected async runExclusive<T>(callback: () => Promise<T>): Promise<T> {
+    return await this.lock.acquire(`lock-${this.database.name}`, callback);
   }
 
   protected generateSyncStreamImplementation(

packages/web/src/db/PowerSyncDatabase.ts

@@ -179,7 +179,7 @@ export class PowerSyncDatabase extends AbstractPowerSyncDatabase {
     return new SqliteBucketStorage(this.database, AbstractPowerSyncDatabase.transactionMutex);
   }
 
-  protected runExclusive<T>(cb: () => Promise<T>) {
+  protected async runExclusive<T>(cb: () => Promise<T>) {
     if (this.resolvedFlags.ssrMode) {
       return PowerSyncDatabase.SHARED_MUTEX.runExclusive(cb);
     }

packages/web/tests/src/db/AbstractPowerSyncDatabase.test.ts

@@ -31,8 +31,8 @@ class TestPowerSyncDatabase extends AbstractPowerSyncDatabase {
     return Promise.resolve();
   }
 
-  protected async connectExclusive(callback: () => Promise<void>): Promise<void> {
-    await callback();
+  protected async runExclusive<T>(callback: () => Promise<T>): Promise<T> {
+    return await callback();
   }
 
   get database() {

packages/web/tests/src/db/PowersyncDatabase.test.ts

@@ -1,5 +1,5 @@
-import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
-import { AbstractPowerSyncDatabase, PowerSyncDatabase, SyncStreamConnectionMethod } from '@powersync/web';
+import { createBaseLogger, PowerSyncDatabase } from '@powersync/web';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { testSchema } from '../../utils/testDb';
 
 describe('PowerSyncDatabase', () => {
@@ -9,9 +9,10 @@ describe('PowerSyncDatabase', () => {
   let mockSyncImplementation: any;
 
   beforeEach(() => {
+    const logger = createBaseLogger();
     mockLogger = {
-      debug: vi.fn(),
-      warn: vi.fn()
+      debug: vi.spyOn(logger, 'debug'),
+      warn: vi.spyOn(logger, 'warn')
     };
 
     // Initialize with minimal required options
@@ -20,12 +21,8 @@ describe('PowerSyncDatabase', () => {
       database: {
         dbFilename: 'test.db'
       },
-      logger: mockLogger
+      logger
     });
-
-    vi.spyOn(db as any, 'runExclusive').mockImplementation((cb: any) => cb());
-
-    vi.spyOn(AbstractPowerSyncDatabase.prototype, 'connect').mockResolvedValue(undefined);
   });
 
   afterEach(() => {
@@ -36,27 +33,6 @@ describe('PowerSyncDatabase', () => {
     it('should log debug message when attempting to connect', async () => {
       await db.connect(mockConnector);
       expect(mockLogger.debug).toHaveBeenCalledWith('Attempting to connect to PowerSync instance');
-      expect(db['runExclusive']).toHaveBeenCalled();
-    });
-
-    it('should use connect with correct options', async () => {
-      await db.connect(mockConnector, {
-        retryDelayMs: 1000,
-        crudUploadThrottleMs: 2000,
-        params: {
-          param1: 1
-        },
-        connectionMethod: SyncStreamConnectionMethod.HTTP
-      });
-
-      expect(AbstractPowerSyncDatabase.prototype.connect).toHaveBeenCalledWith(mockConnector, {
-        retryDelayMs: 1000,
-        crudUploadThrottleMs: 2000,
-        connectionMethod: 'http',
-        params: {
-          param1: 1
-        }
-      });
     });
   });
 });