@powersync/web 1.39.0 → 2.1.0

package/src/worker/db/MultiDatabaseServer.ts

@@ -1,28 +1,39 @@
-import { ILogger } from '@powersync/common';
+import { LogLevels, PowerSyncLogger } from '@powersync/common';
 import * as Comlink from 'comlink';
 import { ClientConnectionView, DatabaseServer } from '../../db/adapters/wa-sqlite/DatabaseServer.js';
-import {
-  ResolvedWASQLiteOpenFactoryOptions,
-  WorkerDBOpenerOptions
-} from '../../db/adapters/wa-sqlite/WASQLiteOpenFactory.js';
 import { getNavigatorLocks } from '../../shared/navigator.js';
-import { RawSqliteConnection } from '../../db/adapters/wa-sqlite/RawSqliteConnection.js';
+import { RawSqliteConnection, RawWaSqliteDatabaseOptions } from '../../db/adapters/wa-sqlite/RawSqliteConnection.js';
 import { ConcurrentSqliteConnection } from '../../db/adapters/wa-sqlite/ConcurrentConnection.js';
 import { WASQLiteVFS } from '../../db/adapters/wa-sqlite/vfs.js';
 
 const OPEN_DB_LOCK = 'open-wasqlite-db';
 
+export interface ConnectToMultiDatabaseServerOptions {
+  logLevel: number;
+  database: RawWaSqliteDatabaseOptions;
+  lockName: string;
+}
+
 /**
  * Shared state to manage multiple database connections hosted by a worker.
  */
 export class MultiDatabaseServer {
   private activeDatabases = new Map<string, DatabaseServer>();
 
-  constructor(readonly logger: ILogger) {}
+  constructor(readonly logger: PowerSyncLogger) {}
 
-  async handleConnection(options: WorkerDBOpenerOptions): Promise<ClientConnectionView> {
-    this.logger.setLevel(options.logLevel);
-    return Comlink.proxy(await this.openConnectionLocally(options, options.lockName));
+  async handleConnection({
+    logLevel,
+    database,
+    lockName
+  }: ConnectToMultiDatabaseServerOptions): Promise<ClientConnectionView> {
+    const logger: PowerSyncLogger = {
+      log: (record) => {
+        if (record.level >= logLevel) this.logger.log(record);
+      }
+    };
+
+    return Comlink.proxy(await this.openConnectionLocally(logger, database, lockName));
   }
 
   async connectToExisting(name: string, lockName: string): Promise<ClientConnectionView> {
@@ -36,7 +47,7 @@ export class MultiDatabaseServer {
     });
   }
 
-  async openConnectionLocally(options: ResolvedWASQLiteOpenFactoryOptions, lockName?: string) {
+  async openConnectionLocally(logger: PowerSyncLogger, options: RawWaSqliteDatabaseOptions, lockName?: string) {
     // Especially on Firefox, we're sometimes seeing "NoModificationAllowedError"s when opening OPFS databases we can
     // work around by retrying.
     const maxAttempts = 3;
@@ -44,29 +55,36 @@ export class MultiDatabaseServer {
 
     for (let count = 0; count < maxAttempts - 1; count++) {
       try {
-        server = await this.databaseOpenAttempt(options);
-      } catch (ex) {
-        this.logger.warn(`Attempt ${count + 1} of ${maxAttempts} to open database failed, retrying in 1 second...`, ex);
+        server = await this.databaseOpenAttempt(logger, options);
+      } catch (error) {
+        this.logger.log({
+          level: LogLevels.warn,
+          message: `Attempt ${count + 1} of ${maxAttempts} to open database failed, retrying in 1 second...`,
+          error
+        });
         await new Promise((resolve) => setTimeout(resolve, 1000));
       }
     }
 
     // Final attempt if we haven't been able to open the server - rethrow errors if we still can't open.
-    server ??= await this.databaseOpenAttempt(options);
+    server ??= await this.databaseOpenAttempt(logger, options);
     return server.connect(lockName);
   }
 
-  private async databaseOpenAttempt(options: ResolvedWASQLiteOpenFactoryOptions): Promise<DatabaseServer> {
+  private async databaseOpenAttempt(
+    logger: PowerSyncLogger,
+    options: RawWaSqliteDatabaseOptions
+  ): Promise<DatabaseServer> {
     return getNavigatorLocks().request(OPEN_DB_LOCK, async () => {
-      const { dbFilename, isReadOnly, vfs } = options;
+      const { filename, readonly, vfs } = options;
 
-      let server: DatabaseServer | undefined = this.activeDatabases.get(dbFilename);
+      let server: DatabaseServer | undefined = this.activeDatabases.get(filename);
       if (server == null) {
         // We don't need navigator locks for shared workers because all queries run in this shared worker exclusively.
         // For read-only connections, we use a VFS that supports concurrent reads (so a single lock on the connection is
         // fine). In-memory databases either run in a shared worker or aren't shared across tabs at all, so the internal
         // lock is enough.
-        const needsNavigatorLocks = !(isSharedWorker || isReadOnly || vfs == WASQLiteVFS.InMemoryVfs);
+        const needsNavigatorLocks = !(isSharedWorker || readonly || vfs == WASQLiteVFS.InMemoryVfs);
         const connection = new RawSqliteConnection(options);
         const withSafeConcurrency = new ConcurrentSqliteConnection(connection, needsNavigatorLocks);
 
@@ -83,13 +101,13 @@ export class MultiDatabaseServer {
         }
         returnLease();
 
-        const onClose = () => this.activeDatabases.delete(dbFilename);
+        const onClose = () => this.activeDatabases.delete(filename);
         server = new DatabaseServer({
           inner: withSafeConcurrency,
-          logger: this.logger,
+          logger,
           onClose
         });
-        this.activeDatabases.set(dbFilename, server);
+        this.activeDatabases.set(filename, server);
       }
 
       return server;

package/src/worker/sync/AbstractSharedSyncClientProvider.ts

@@ -1,4 +1,5 @@
-import type { PowerSyncCredentials, SyncStatusOptions } from '@powersync/common';
+import type { LogRecord, PowerSyncCredentials } from '@powersync/common';
+import { SyncStatusJson } from '@powersync/shared-internals';
 
 /**
  * The client side port should provide these methods.
@@ -7,15 +8,8 @@ export abstract class AbstractSharedSyncClientProvider {
   abstract fetchCredentials(): Promise<PowerSyncCredentials | null>;
   abstract invalidateCredentials(): void;
   abstract uploadCrud(): Promise<void>;
-  abstract statusChanged(status: SyncStatusOptions): void;
+  abstract statusChanged(status: SyncStatusJson): void;
   abstract getDBWorkerPort(): Promise<MessagePort>;
 
-  abstract trace(...x: any[]): void;
-  abstract debug(...x: any[]): void;
-  abstract info(...x: any[]): void;
-  abstract log(...x: any[]): void;
-  abstract warn(...x: any[]): void;
-  abstract error(...x: any[]): void;
-  abstract time(label: string): void;
-  abstract timeEnd(label: string): void;
+  abstract log(record: LogRecord): void;
 }

package/src/worker/sync/BroadcastLogger.ts

@@ -1,113 +1,39 @@
-import { type ILogger, type ILogLevel, LogLevel } from '@powersync/common';
+import { PowerSyncLogger, LogLevels, CreateLoggerOptions, createConsoleLogger, LogRecord } from '@powersync/common';
 import { type WrappedSyncPort } from './SharedSyncImplementation.js';
 
 /**
  * Broadcasts logs to all clients
  */
-export class BroadcastLogger implements ILogger {
-  TRACE: ILogLevel;
-  DEBUG: ILogLevel;
-  INFO: ILogLevel;
-  TIME: ILogLevel;
-  WARN: ILogLevel;
-  ERROR: ILogLevel;
-  OFF: ILogLevel;
+export class BroadcastLogger implements PowerSyncLogger {
+  private readonly inner: PowerSyncLogger & CreateLoggerOptions;
+  private currentLevel: number = LogLevels.info;
 
-  private currentLevel: ILogLevel = LogLevel.INFO;
+  sendBroadcasts = true;
 
-  constructor(protected clients: WrappedSyncPort[]) {
-    this.TRACE = LogLevel.TRACE;
-    this.DEBUG = LogLevel.DEBUG;
-    this.INFO = LogLevel.INFO;
-    this.TIME = LogLevel.TIME;
-    this.WARN = LogLevel.WARN;
-    this.ERROR = LogLevel.ERROR;
-    this.OFF = LogLevel.OFF;
+  constructor(
+    prefix: string,
+    private clients: WrappedSyncPort[]
+  ) {
+    this.inner = createConsoleLogger({ prefix: prefix });
   }
 
-  trace(...x: any[]): void {
-    if (!this.enabledFor(this.TRACE)) return;
+  log(record: LogRecord) {
+    this.inner.log(record);
 
-    console.trace(...x);
-    const sanitized = this.sanitizeArgs(x);
-    this.iterateClients((client) => client.clientProvider.trace(...sanitized));
-  }
-
-  debug(...x: any[]): void {
-    if (!this.enabledFor(this.DEBUG)) return;
-
-    console.debug(...x);
-    const sanitized = this.sanitizeArgs(x);
-    this.iterateClients((client) => client.clientProvider.debug(...sanitized));
-  }
-
-  info(...x: any[]): void {
-    if (!this.enabledFor(this.INFO)) return;
-
-    console.info(...x);
-    const sanitized = this.sanitizeArgs(x);
-    this.iterateClients((client) => client.clientProvider.info(...sanitized));
-  }
-
-  log(...x: any[]): void {
-    if (!this.enabledFor(this.INFO)) return;
-
-    console.log(...x);
-    const sanitized = this.sanitizeArgs(x);
-    this.iterateClients((client) => client.clientProvider.log(...sanitized));
-  }
-
-  warn(...x: any[]): void {
-    if (!this.enabledFor(this.WARN)) return;
-
-    console.warn(...x);
-    const sanitized = this.sanitizeArgs(x);
-    this.iterateClients((client) => client.clientProvider.warn(...sanitized));
-  }
-
-  error(...x: any[]): void {
-    if (!this.enabledFor(this.ERROR)) return;
-
-    console.error(...x);
-    const sanitized = this.sanitizeArgs(x);
-    this.iterateClients((client) => client.clientProvider.error(...sanitized));
-  }
-
-  time(label: string): void {
-    if (!this.enabledFor(this.TIME)) return;
-
-    console.time(label);
-    this.iterateClients((client) => client.clientProvider.time(label));
-  }
-
-  timeEnd(label: string): void {
-    if (!this.enabledFor(this.TIME)) return;
-
-    console.timeEnd(label);
-    this.iterateClients((client) => client.clientProvider.timeEnd(label));
+    if (this.sendBroadcasts && record.level >= this.currentLevel) {
+      const sanitized = this.sanitizeRecord(record);
+      this.iterateClients((client) => client.clientProvider.log(sanitized));
+    }
   }
 
   /**
    * Set the global log level.
    */
-  setLevel(level: ILogLevel): void {
+  setLevel(level: number): void {
+    this.inner.minLevel = level;
     this.currentLevel = level;
   }
 
-  /**
-   * Get the current log level.
-   */
-  getLevel(): ILogLevel {
-    return this.currentLevel;
-  }
-
-  /**
-   * Returns true if the given level is enabled.
-   */
-  enabledFor(level: ILogLevel): boolean {
-    return level.value >= this.currentLevel.value;
-  }
-
   /**
    * Iterates all clients, catches individual client exceptions
    * and proceeds to execute for all clients.
@@ -126,17 +52,23 @@ export class BroadcastLogger implements ILogger {
    * Guards against any logging errors.
    * We don't want a logging exception to cause further issues upstream
    */
-  protected sanitizeArgs(x: any[]): any[] {
-    const sanitizedParams = x.map((param) => {
-      try {
-        // Try and clone here first. If it fails it won't be passable over a MessagePort
-        return structuredClone(param);
-      } catch (ex) {
-        console.error(ex);
-        return 'Could not serialize log params. Check shared worker logs for more details.';
-      }
-    });
+  protected sanitizeRecord(record: LogRecord): LogRecord {
+    if (!record.error) {
+      return record;
+    }
+
+    let error;
+    try {
+      // Try and clone here first. If it fails it won't be passable over a MessagePort
+      error = structuredClone(record.error);
+    } catch (ex) {
+      console.error(ex);
+      error = 'Could not serialize log params. Check shared worker logs for more details.';
+    }
 
-    return sanitizedParams;
+    return {
+      ...record,
+      error
+    };
   }
 }

package/src/worker/sync/SharedSyncImplementation.ts

@@ -1,26 +1,24 @@
 import {
-  AbortOperation,
   BaseObserver,
-  ConnectionManager,
-  ConnectionPool,
   DBAdapter,
-  DBAdapterDefaultMixin,
-  DBAdapterListener,
   DBLockOptions,
   LockContext,
   PowerSyncBackendConnector,
+  SyncStatus,
+  LogLevels,
+  SyncStreamConnectionMethod
+} from '@powersync/common';
+import {
+  AbortOperation,
+  ConnectionManager,
   SqliteBucketStorage,
   SubscribedStream,
-  SyncStatus,
-  createLogger,
-  Mutex,
-  type ILogLevel,
-  type ILogger,
-  type PowerSyncConnectionOptions,
   type StreamingSyncImplementation,
   type StreamingSyncImplementationListener,
-  type SyncStatusOptions
-} from '@powersync/common';
+  Mutex,
+  ResolvedSyncOptions,
+  SyncStatusSnapshot
+} from '@powersync/shared-internals';
 import * as Comlink from 'comlink';
 import { WebRemote } from '../../db/sync/WebRemote.js';
 import {
@@ -28,11 +26,11 @@ import {
   WebStreamingSyncImplementationOptions
 } from '../../db/sync/WebStreamingSyncImplementation.js';
 
-import { ResolvedWebSQLOpenOptions } from '../../db/adapters/web-sql-flags.js';
 import { AbstractSharedSyncClientProvider } from './AbstractSharedSyncClientProvider.js';
 import { BroadcastLogger } from './BroadcastLogger.js';
 import { DatabaseClient, OpenWorkerConnection } from '../../db/adapters/wa-sqlite/DatabaseClient.js';
 import { generateTabCloseSignal } from '../../shared/tab_close_signal.js';
+import { ResolvedWebSQLOpenOptions } from '../../db/adapters/options.js';
 
 /**
  * @internal
@@ -60,8 +58,12 @@ export type ManualSharedSyncPayload = {
  * @internal
  */
 export type SharedSyncInitOptions = {
-  streamOptions: Omit<WebStreamingSyncImplementationOptions, 'adapter' | 'uploadCrud' | 'remote' | 'subscriptions'>;
+  streamOptions: Omit<
+    WebStreamingSyncImplementationOptions,
+    'adapter' | 'uploadCrud' | 'remote' | 'subscriptions' | 'logger'
+  >;
   dbParams: ResolvedWebSQLOpenOptions;
+  enableBroadcastLogs: boolean;
 };
 
 /**
@@ -112,21 +114,21 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
   protected uploadDataController?: RemoteOperationAbortController;
 
   protected syncParams: SharedSyncInitOptions | null;
-  protected logger: ILogger;
-  protected lastConnectOptions: PowerSyncConnectionOptions | undefined;
+  protected lastConnectOptions: ResolvedSyncOptions | undefined;
   protected portMutex: Mutex;
   private subscriptions: SubscribedStream[] = [];
 
   protected connectionManager: ConnectionManager;
-  syncStatus: SyncStatus;
-  broadCastLogger: ILogger;
+  private syncStatus?: SyncStatusSnapshot;
+  logger: BroadcastLogger;
   protected readonly database = this.generateReconnectableDatabase();
 
+  private sharedCloseSignal = generateTabCloseSignal();
+
   constructor() {
     super();
     this.ports = [];
     this.syncParams = null;
-    this.logger = createLogger('shared-sync');
     this.lastConnectOptions = undefined;
     this.portMutex = new Mutex();
 
@@ -139,8 +141,7 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
       });
     });
 
-    this.syncStatus = new SyncStatus({});
-    this.broadCastLogger = new BroadcastLogger(this.ports);
+    this.logger = new BroadcastLogger('shared-sync', this.ports);
 
     this.connectionManager = new ConnectionManager({
       createSyncImplementation: async () => {
@@ -148,8 +149,10 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
 
         const sync = this.generateStreamingImplementation();
         const onDispose = sync.registerListener({
-          statusChanged: (status) => {
-            this.updateAllStatuses(status.toJSON());
+          statusChanged: (snapshot) => {
+            this.syncStatus = snapshot;
+            const json = snapshot.toJSON();
+            this.ports.forEach((p) => p.clientProvider.statusChanged(json));
           }
         });
 
@@ -158,7 +161,8 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
           onDispose
         };
       },
-      logger: this.logger
+      logger: this.logger,
+      defaultConnectionMethod: SyncStreamConnectionMethod.HTTP
     });
   }
 
@@ -192,12 +196,6 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
     });
   }
 
-  async waitForStatus(status: SyncStatusOptions): Promise<void> {
-    return this.withSyncImplementation(async (sync) => {
-      return sync.waitForStatus(status);
-    });
-  }
-
   async waitUntilStatusMatches(predicate: (status: SyncStatus) => boolean): Promise<void> {
     return this.withSyncImplementation(async (sync) => {
       return sync.waitUntilStatusMatches(predicate);
@@ -209,7 +207,7 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
   }
 
   private collectActiveSubscriptions() {
-    this.logger.debug('Collecting active stream subscriptions across tabs');
+    this.logger.log({ level: LogLevels.debug, message: 'Collecting active stream subscriptions across tabs' });
     const active = new Map<string, SubscribedStream>();
     for (const port of this.ports) {
       for (const stream of port.currentSubscriptions) {
@@ -218,7 +216,10 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
       }
     }
     this.subscriptions = [...active.values()];
-    this.logger.debug('Collected stream subscriptions', this.subscriptions);
+    this.logger.log({
+      level: LogLevels.debug,
+      message: `Collected stream subscriptions, ${JSON.stringify(this.subscriptions)}`
+    });
     this.connectionManager.syncStreamImplementation?.updateSubscriptions(this.subscriptions);
   }
 
@@ -227,9 +228,8 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
     this.collectActiveSubscriptions();
   }
 
-  setLogLevel(level: ILogLevel) {
+  setLogLevel(level: number) {
     this.logger.setLevel(level);
-    this.broadCastLogger.setLevel(level);
   }
 
   /**
@@ -247,16 +247,18 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
 
     // First time setting params
     this.syncParams = params;
-    if (params.streamOptions?.flags?.broadcastLogs) {
-      this.logger = this.broadCastLogger;
-    }
+    this.logger.sendBroadcasts = params.enableBroadcastLogs;
 
     // Ensure we have a usable database connection, the reconnectable database will connect lazily on first use.
     await this.database.readLock(async () => {});
 
     self.onerror = (event) => {
       // Share any uncaught events on the broadcast logger
-      this.logger.error('Uncaught exception in PowerSync shared sync worker', event);
+      this.logger.log({
+        level: LogLevels.error,
+        message: 'Uncaught exception in PowerSync shared sync worker',
+        error: event
+      });
     };
 
     this.iterateListeners((l) => l.initialized?.());
@@ -274,9 +276,9 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
    * The connection will simply be reconnected whenever a new tab
    * connects.
    */
-  async connect(options?: PowerSyncConnectionOptions) {
+  async connect(options: ResolvedSyncOptions, serializedSchema: any) {
     this.lastConnectOptions = options;
-    return this.connectionManager.connect(CONNECTOR_PLACEHOLDER, options ?? {});
+    return this.connectionManager.connect(CONNECTOR_PLACEHOLDER, options ?? {}, serializedSchema);
   }
 
   async disconnect() {
@@ -298,7 +300,7 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
       this.ports.push(portProvider);
 
       // Give the newly connected client the latest status
-      const status = this.connectionManager.syncStreamImplementation?.syncStatus;
+      const status = this.syncStatus;
       if (status) {
         portProvider.clientProvider.statusChanged(status.toJSON());
       }
@@ -321,7 +323,10 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
     return await this.portMutex.runExclusive(async () => {
       const index = this.ports.findIndex((p) => p == port);
       if (index < 0) {
-        this.logger.warn(`Could not remove port ${port} since it is not present in active ports.`);
+        this.logger.log({
+          level: LogLevels.warn,
+          message: `Could not remove port ${port} since it is not present in active ports.`
+        });
         return () => {};
       }
 
@@ -397,10 +402,13 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
               throw new Error('No client port found to invalidate credentials');
             }
             try {
-              this.logger.log('calling the last port client provider to invalidate credentials');
+              this.logger.log({
+                level: LogLevels.info,
+                message: 'calling the last port client provider to invalidate credentials'
+              });
               lastPort.clientProvider.invalidateCredentials();
-            } catch (ex) {
-              this.logger.error('error invalidating credentials', ex);
+            } catch (error) {
+              this.logger.log({ level: LogLevels.error, message: 'error invalidating credentials', error });
             }
           },
           fetchCredentials: async () => {
@@ -417,7 +425,10 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
 
               abortController.signal.onabort = reject;
               try {
-                this.logger.log('calling the last port client provider for credentials');
+                this.logger.log({
+                  level: LogLevels.info,
+                  message: 'calling the last port client provider for credentials'
+                });
                 resolve(await lastPort.clientProvider.fetchCredentials());
               } catch (ex) {
                 reject(ex);
@@ -508,7 +519,7 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
     const remote = Comlink.wrap<OpenWorkerConnection>(workerPort);
     const identifier = this.syncParams!.dbParams.dbFilename;
 
-    const clientLockName = await generateTabCloseSignal();
+    const clientLockName = await this.sharedCloseSignal;
 
     /**
      * The open could fail if the tab is closed while we're busy opening the database.
@@ -542,7 +553,7 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
     clearTimeout(timeout);
 
     client.closeListeners.push(async () => {
-      this.logger.info('Aborting open connection because associated tab closed.');
+      this.logger.log({ level: LogLevels.info, message: 'Aborting open connection because associated tab closed.' });
       handleClosed(db);
       /**
        * Don't await this close operation. It might never resolve if the tab is closed.
@@ -550,7 +561,9 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
        * We then call close. The close operation is configured to fire-and-forget, the main promise will reject immediately.
        */
       db.markRemoteClosed();
-      db.close().catch((ex) => this.logger.warn('error closing database connection', ex));
+      db.close().catch((error) =>
+        this.logger.log({ level: LogLevels.warn, message: 'error closing database connection', error })
+      );
     });
     return db;
   }
@@ -559,7 +572,7 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
     const syncParams = this.syncParams;
     const sharedSync = this;
 
-    class ReconnectPool extends BaseObserver<DBAdapterListener> implements ConnectionPool {
+    return new (class extends DBAdapter {
       private connectionState:
         | null
         | DatabaseClient<ResolvedWebSQLOpenOptions>
@@ -628,19 +641,7 @@ export class SharedSyncImplementation extends BaseObserver<SharedSyncImplementat
       async refreshSchema(): Promise<void> {
         // Not used by sync client.
       }
-    }
-
-    const Adapter = DBAdapterDefaultMixin(ReconnectPool);
-    return new Adapter();
-  }
-
-  /**
-   * A method to update the all shared statuses for each
-   * client.
-   */
-  private updateAllStatuses(status: SyncStatusOptions) {
-    this.syncStatus = new SyncStatus(status);
-    this.ports.forEach((p) => p.clientProvider.statusChanged(status));
+    })();
   }
 }
 

package/src/worker/sync/WorkerClient.ts

@@ -1,4 +1,3 @@
-import { ILogLevel, PowerSyncConnectionOptions, SubscribedStream } from '@powersync/common';
 import * as Comlink from 'comlink';
 import { getNavigatorLocks } from '../../shared/navigator.js';
 import {
@@ -8,6 +7,7 @@ import {
   SharedSyncInitOptions,
   WrappedSyncPort
 } from './SharedSyncImplementation.js';
+import { SubscribedStream, ResolvedSyncOptions } from '@powersync/shared-internals';
 
 /**
  * A client to the shared sync worker.
@@ -65,7 +65,7 @@ export class WorkerClient {
     });
   }
 
-  setLogLevel(level: ILogLevel) {
+  setLogLevel(level: number) {
     this.sync.setLogLevel(level);
   }
 
@@ -82,8 +82,8 @@ export class WorkerClient {
     return this.sync.getWriteCheckpoint();
   }
 
-  connect(options?: PowerSyncConnectionOptions) {
-    return this.sync.connect(options);
+  connect(options: ResolvedSyncOptions, schema: any) {
+    return this.sync.connect(options, schema);
   }
 
   updateSubscriptions(subscriptions: SubscribedStream[]) {