@powersync/web 1.17.2 → 1.19.0

package/lib/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@powersync/web",
-    "version": "1.17.2",
+    "version": "1.19.0",
     "description": "PowerSync web SDK. Sync Postgres, MongoDB or MySQL with SQLite in your web app",
     "main": "lib/src/index.js",
     "types": "lib/src/index.d.ts",
@@ -61,15 +61,14 @@
     "license": "Apache-2.0",
     "peerDependencies": {
         "@journeyapps/wa-sqlite": "^1.2.2",
-        "@powersync/common": "workspace:^1.27.1"
+        "@powersync/common": "workspace:^1.28.0"
     },
     "dependencies": {
         "@powersync/common": "workspace:*",
         "async-mutex": "^0.4.0",
         "bson": "^6.6.0",
         "comlink": "^4.4.2",
-        "commander": "^12.1.0",
-        "js-logger": "^1.6.1"
+        "commander": "^12.1.0"
     },
     "devDependencies": {
         "@journeyapps/wa-sqlite": "^1.2.2",

package/lib/src/db/adapters/AbstractWebSQLOpenFactory.d.ts

@@ -1,5 +1,4 @@
-import { DBAdapter, SQLOpenFactory } from '@powersync/common';
-import { ILogger } from 'js-logger';
+import { type ILogger, DBAdapter, SQLOpenFactory } from '@powersync/common';
 import { ResolvedWebSQLFlags, WebSQLOpenFactoryOptions } from './web-sql-flags';
 export declare abstract class AbstractWebSQLOpenFactory implements SQLOpenFactory {
     protected options: WebSQLOpenFactoryOptions;

package/lib/src/db/adapters/AbstractWebSQLOpenFactory.js

@@ -1,4 +1,4 @@
-import Logger from 'js-logger';
+import { createLogger } from '@powersync/common';
 import { SSRDBAdapter } from './SSRDBAdapter';
 import { isServerSide, resolveWebSQLFlags } from './web-sql-flags';
 export class AbstractWebSQLOpenFactory {
@@ -8,7 +8,7 @@ export class AbstractWebSQLOpenFactory {
     constructor(options) {
         this.options = options;
         this.resolvedFlags = resolveWebSQLFlags(options.flags);
-        this.logger = options.logger ?? Logger.get(`AbstractWebSQLOpenFactory - ${this.options.dbFilename}`);
+        this.logger = options.logger ?? createLogger(`AbstractWebSQLOpenFactory - ${this.options.dbFilename}`);
     }
     /**
      * Opens a {@link DBAdapter} using resolved flags.
@@ -17,13 +17,13 @@ export class AbstractWebSQLOpenFactory {
     openDB() {
         const { resolvedFlags: { disableSSRWarning, enableMultiTabs, ssrMode = isServerSide() } } = this;
         if (ssrMode && !disableSSRWarning) {
-            console.warn(`
+            this.logger.warn(`
   Running PowerSync in SSR mode.
   Only empty query results will be returned.
   Disable this warning by setting 'disableSSRWarning: true' in options.`);
         }
         if (!enableMultiTabs) {
-            console.warn('Multiple tab support is not enabled. Using this site across multiple tabs may not function correctly.');
+            this.logger.warn('Multiple tab support is not enabled. Using this site across multiple tabs may not function correctly.');
         }
         if (ssrMode) {
             return new SSRDBAdapter();

package/lib/src/db/adapters/LockedAsyncDatabaseAdapter.d.ts

@@ -1,5 +1,4 @@
-import { BaseObserver, DBAdapterListener, DBLockOptions, LockContext, QueryResult, Transaction } from '@powersync/common';
-import { ILogger } from 'js-logger';
+import { type ILogger, BaseObserver, DBAdapterListener, DBLockOptions, LockContext, QueryResult, Transaction } from '@powersync/common';
 import { AsyncDatabaseConnection } from './AsyncDatabaseConnection';
 import { SharedConnectionWorker, WebDBAdapter } from './WebDBAdapter';
 import { ResolvedWebSQLOpenOptions } from './web-sql-flags';

package/lib/src/db/adapters/LockedAsyncDatabaseAdapter.js

@@ -1,5 +1,4 @@
-import { BaseObserver } from '@powersync/common';
-import Logger from 'js-logger';
+import { BaseObserver, createLogger } from '@powersync/common';
 import { getNavigatorLocks } from '../..//shared/navigator';
 import { WorkerWrappedAsyncDatabaseConnection } from './WorkerWrappedAsyncDatabaseConnection';
 /**
@@ -21,7 +20,7 @@ export class LockedAsyncDatabaseAdapter extends BaseObserver {
         super();
         this.options = options;
         this._dbIdentifier = options.name;
-        this.logger = options.logger ?? Logger.get(`LockedAsyncDatabaseAdapter - ${this._dbIdentifier}`);
+        this.logger = options.logger ?? createLogger(`LockedAsyncDatabaseAdapter - ${this._dbIdentifier}`);
         // Set the name if provided. We can query for the name if not available yet
         this.debugMode = options.debugMode ?? false;
         if (this.debugMode) {

package/lib/src/db/adapters/wa-sqlite/WASQLiteOpenFactory.d.ts

@@ -1,4 +1,4 @@
-import { DBAdapter } from '@powersync/common';
+import { type ILogLevel, DBAdapter } from '@powersync/common';
 import { AbstractWebSQLOpenFactory } from '../AbstractWebSQLOpenFactory';
 import { AsyncDatabaseConnection } from '../AsyncDatabaseConnection';
 import { ResolvedWebSQLOpenOptions, WebSQLOpenFactoryOptions } from '../web-sql-flags';
@@ -9,6 +9,9 @@ export interface WASQLiteOpenFactoryOptions extends WebSQLOpenFactoryOptions {
 export interface ResolvedWASQLiteOpenFactoryOptions extends ResolvedWebSQLOpenOptions {
     vfs: WASQLiteVFS;
 }
+export interface WorkerDBOpenerOptions extends ResolvedWASQLiteOpenFactoryOptions {
+    logLevel: ILogLevel;
+}
 /**
  * Opens a SQLite connection using WA-SQLite.
  */

package/lib/src/db/adapters/wa-sqlite/WASQLiteOpenFactory.js

@@ -51,7 +51,8 @@ export class WASQLiteOpenFactory extends AbstractWebSQLOpenFactory {
                     temporaryStorage,
                     cacheSizeKb,
                     flags: this.resolvedFlags,
-                    encryptionKey: encryptionKey
+                    encryptionKey: encryptionKey,
+                    logLevel: this.logger.getLevel()
                 }),
                 identifier: this.options.dbFilename,
                 onClose: () => {

package/lib/src/db/adapters/web-sql-flags.d.ts

@@ -1,5 +1,4 @@
-import { SQLOpenOptions } from '@powersync/common';
-import { ILogger } from 'js-logger';
+import { type ILogger, SQLOpenOptions } from '@powersync/common';
 /**
  * Common settings used when creating SQL connections on web.
  */

package/lib/src/db/sync/SharedWebStreamingSyncImplementation.js

@@ -112,6 +112,7 @@ export class SharedWebStreamingSyncImplementation extends WebStreamingSyncImplem
             }).port;
         }
         this.syncManager = Comlink.wrap(this.messagePort);
+        this.syncManager.setLogLevel(this.logger.getLevel());
         this.triggerCrudUpload = this.syncManager.triggerCrudUpload;
         /**
          * Opens MessagePort to the existing shared DB worker.

package/lib/src/db/sync/WebRemote.d.ts

@@ -1,5 +1,4 @@
-import { type ILogger } from 'js-logger';
-import { AbstractRemote, AbstractRemoteOptions, BSONImplementation, RemoteConnector } from '@powersync/common';
+import { AbstractRemote, AbstractRemoteOptions, BSONImplementation, ILogger, RemoteConnector } from '@powersync/common';
 export declare class WebRemote extends AbstractRemote {
     protected connector: RemoteConnector;
     protected logger: ILogger;

package/lib/src/db/sync/WebStreamingSyncImplementation.js

@@ -10,7 +10,9 @@ export class WebStreamingSyncImplementation extends AbstractStreamingSyncImpleme
     }
     obtainLock(lockOptions) {
         const identifier = `streaming-sync-${lockOptions.type}-${this.webOptions.identifier}`;
-        lockOptions.type == LockType.SYNC && console.debug('requesting lock for ', identifier);
+        if (lockOptions.type == LockType.SYNC) {
+            this.logger.debug('requesting lock for ', identifier);
+        }
         return getNavigatorLocks().request(identifier, { signal: lockOptions.signal }, lockOptions.callback);
     }
 }

package/lib/src/worker/db/WASQLiteDB.worker.js

@@ -5,6 +5,10 @@ import '@journeyapps/wa-sqlite';
 import * as Comlink from 'comlink';
 import { WASqliteConnection } from '../../db/adapters/wa-sqlite/WASQLiteConnection';
 import { getNavigatorLocks } from '../../shared/navigator';
+import { createBaseLogger, createLogger } from '@powersync/common';
+const baseLogger = createBaseLogger();
+baseLogger.useDefaults();
+const logger = createLogger('db-worker');
 const DBMap = new Map();
 const OPEN_DB_LOCK = 'open-wasqlite-db';
 let nextClientId = 1;
@@ -27,7 +31,8 @@ const openDBShared = async (options) => {
     // Prevent multiple simultaneous opens from causing race conditions
     return getNavigatorLocks().request(OPEN_DB_LOCK, async () => {
         const clientId = nextClientId++;
-        const { dbFilename } = options;
+        const { dbFilename, logLevel } = options;
+        logger.setLevel(logLevel);
         if (!DBMap.has(dbFilename)) {
             const clientIds = new Set();
             const connection = await openWorkerConnection(options);
@@ -47,14 +52,14 @@ const openDBShared = async (options) => {
             }),
             close: Comlink.proxy(() => {
                 const { clientIds } = dbEntry;
-                console.debug(`Close requested from client ${clientId} of ${[...clientIds]}`);
+                logger.debug(`Close requested from client ${clientId} of ${[...clientIds]}`);
                 clientIds.delete(clientId);
                 if (clientIds.size == 0) {
-                    console.debug(`Closing connection to ${dbFilename}.`);
+                    logger.debug(`Closing connection to ${dbFilename}.`);
                     DBMap.delete(dbFilename);
                     return db.close?.();
                 }
-                console.debug(`Connection to ${dbFilename} not closed yet due to active clients.`);
+                logger.debug(`Connection to ${dbFilename} not closed yet due to active clients.`);
                 return;
             })
         };
@@ -66,7 +71,6 @@ if (typeof SharedWorkerGlobalScope !== 'undefined') {
     const _self = self;
     _self.onconnect = function (event) {
         const port = event.ports[0];
-        console.debug('Exposing shared db on port', port);
         Comlink.expose(openDBShared, port);
     };
 }

package/lib/src/worker/sync/BroadcastLogger.d.ts

@@ -1,4 +1,4 @@
-import { type ILogLevel, type ILogger } from 'js-logger';
+import { type ILogger, type ILogLevel } from '@powersync/common';
 import { type WrappedSyncPort } from './SharedSyncImplementation';
 /**
  * Broadcasts logs to all clients
@@ -12,6 +12,7 @@ export declare class BroadcastLogger implements ILogger {
     WARN: ILogLevel;
     ERROR: ILogLevel;
     OFF: ILogLevel;
+    private currentLevel;
     constructor(clients: WrappedSyncPort[]);
     trace(...x: any[]): void;
     debug(...x: any[]): void;
@@ -21,8 +22,17 @@ export declare class BroadcastLogger implements ILogger {
     error(...x: any[]): void;
     time(label: string): void;
     timeEnd(label: string): void;
+    /**
+     * Set the global log level.
+     */
     setLevel(level: ILogLevel): void;
+    /**
+     * Get the current log level.
+     */
     getLevel(): ILogLevel;
+    /**
+     * Returns true if the given level is enabled.
+     */
     enabledFor(level: ILogLevel): boolean;
     /**
      * Iterates all clients, catches individual client exceptions

package/lib/src/worker/sync/BroadcastLogger.js

@@ -1,4 +1,4 @@
-import Logger from 'js-logger';
+import { LogLevel } from '@powersync/common';
 /**
  * Broadcasts logs to all clients
  */
@@ -11,64 +11,88 @@ export class BroadcastLogger {
     WARN;
     ERROR;
     OFF;
+    currentLevel = LogLevel.INFO;
     constructor(clients) {
         this.clients = clients;
-        this.TRACE = Logger.TRACE;
-        this.DEBUG = Logger.DEBUG;
-        this.INFO = Logger.INFO;
-        this.TIME = Logger.TIME;
-        this.WARN = Logger.WARN;
-        this.ERROR = Logger.ERROR;
-        this.OFF = Logger.OFF;
+        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;
     }
     trace(...x) {
+        if (!this.enabledFor(this.TRACE))
+            return;
         console.trace(...x);
         const sanitized = this.sanitizeArgs(x);
         this.iterateClients((client) => client.clientProvider.trace(...sanitized));
     }
     debug(...x) {
+        if (!this.enabledFor(this.DEBUG))
+            return;
         console.debug(...x);
         const sanitized = this.sanitizeArgs(x);
         this.iterateClients((client) => client.clientProvider.debug(...sanitized));
     }
     info(...x) {
+        if (!this.enabledFor(this.INFO))
+            return;
         console.info(...x);
         const sanitized = this.sanitizeArgs(x);
         this.iterateClients((client) => client.clientProvider.info(...sanitized));
     }
     log(...x) {
+        if (!this.enabledFor(this.INFO))
+            return;
         console.log(...x);
         const sanitized = this.sanitizeArgs(x);
         this.iterateClients((client) => client.clientProvider.log(...sanitized));
     }
     warn(...x) {
+        if (!this.enabledFor(this.WARN))
+            return;
         console.warn(...x);
         const sanitized = this.sanitizeArgs(x);
         this.iterateClients((client) => client.clientProvider.warn(...sanitized));
     }
     error(...x) {
+        if (!this.enabledFor(this.ERROR))
+            return;
         console.error(...x);
         const sanitized = this.sanitizeArgs(x);
         this.iterateClients((client) => client.clientProvider.error(...sanitized));
     }
     time(label) {
+        if (!this.enabledFor(this.TIME))
+            return;
         console.time(label);
         this.iterateClients((client) => client.clientProvider.time(label));
     }
     timeEnd(label) {
+        if (!this.enabledFor(this.TIME))
+            return;
         console.timeEnd(label);
         this.iterateClients((client) => client.clientProvider.timeEnd(label));
     }
+    /**
+     * Set the global log level.
+     */
     setLevel(level) {
-        // Levels are not adjustable on this level.
+        this.currentLevel = level;
     }
+    /**
+     * Get the current log level.
+     */
     getLevel() {
-        // Levels are not adjustable on this level.
-        return Logger.INFO;
+        return this.currentLevel;
     }
+    /**
+     * Returns true if the given level is enabled.
+     */
     enabledFor(level) {
-        // Levels are not adjustable on this level.
-        return true;
+        return level.value >= this.currentLevel.value;
     }
     /**
      * Iterates all clients, catches individual client exceptions

package/lib/src/worker/sync/SharedSyncImplementation.d.ts

@@ -1,6 +1,5 @@
-import { type AbstractStreamingSyncImplementation, type LockOptions, type PowerSyncConnectionOptions, type StreamingSyncImplementation, type StreamingSyncImplementationListener, type SyncStatusOptions, BaseObserver, DBAdapter, SyncStatus } from '@powersync/common';
+import { type AbstractStreamingSyncImplementation, type ILogger, type ILogLevel, type LockOptions, type PowerSyncConnectionOptions, type StreamingSyncImplementation, type StreamingSyncImplementationListener, type SyncStatusOptions, BaseObserver, DBAdapter, SyncStatus } from '@powersync/common';
 import * as Comlink from 'comlink';
-import { type ILogger } from 'js-logger';
 import { WebStreamingSyncImplementation, WebStreamingSyncImplementationOptions } from '../../db/sync/WebStreamingSyncImplementation';
 import { ResolvedWebSQLOpenOptions } from '../../db/adapters/web-sql-flags';
 import { AbstractSharedSyncClientProvider } from './AbstractSharedSyncClientProvider';
@@ -69,6 +68,7 @@ export declare class SharedSyncImplementation extends BaseObserver<SharedSyncImp
     get lastSyncedAt(): Date | undefined;
     get isConnected(): boolean;
     waitForReady(): Promise<void>;
+    setLogLevel(level: ILogLevel): void;
     /**
      * Configures the DBAdapter connection and a streaming sync client.
      */

package/lib/src/worker/sync/SharedSyncImplementation.js

@@ -1,7 +1,6 @@
-import { AbortOperation, BaseObserver, SqliteBucketStorage, SyncStatus } from '@powersync/common';
+import { AbortOperation, BaseObserver, createLogger, SqliteBucketStorage, SyncStatus } from '@powersync/common';
 import { Mutex } from 'async-mutex';
 import * as Comlink from 'comlink';
-import Logger from 'js-logger';
 import { WebRemote } from '../../db/sync/WebRemote';
 import { WebStreamingSyncImplementation } from '../../db/sync/WebStreamingSyncImplementation';
 import { LockedAsyncDatabaseAdapter } from '../../db/adapters/LockedAsyncDatabaseAdapter';
@@ -42,7 +41,7 @@ export class SharedSyncImplementation extends BaseObserver {
         this.dbAdapter = null;
         this.syncParams = null;
         this.syncStreamClient = null;
-        this.logger = Logger.get('shared-sync');
+        this.logger = createLogger('shared-sync');
         this.lastConnectOptions = undefined;
         this.isInitialized = new Promise((resolve) => {
             const callback = this.registerListener({
@@ -72,6 +71,10 @@ export class SharedSyncImplementation extends BaseObserver {
     async waitForReady() {
         return this.isInitialized;
     }
+    setLogLevel(level) {
+        this.logger.setLevel(level);
+        this.broadCastLogger.setLevel(level);
+    }
     /**
      * Configures the DBAdapter connection and a streaming sync client.
      */
@@ -150,7 +153,7 @@ export class SharedSyncImplementation extends BaseObserver {
     async removePort(port) {
         const index = this.ports.findIndex((p) => p.port == port);
         if (index < 0) {
-            console.warn(`Could not remove port ${port} since it is not present in active ports.`);
+            this.logger.warn(`Could not remove port ${port} since it is not present in active ports.`);
             return;
         }
         const trackedPort = this.ports[index];
@@ -214,7 +217,7 @@ export class SharedSyncImplementation extends BaseObserver {
                         };
                         abortController.signal.onabort = reject;
                         try {
-                            console.log('calling the last port client provider for credentials');
+                            this.logger.log('calling the last port client provider for credentials');
                             resolve(await lastPort.clientProvider.fetchCredentials());
                         }
                         catch (ex) {

package/lib/src/worker/sync/SharedSyncImplementation.worker.js

@@ -1,8 +1,9 @@
 import * as Comlink from 'comlink';
 import { SharedSyncImplementation, SharedSyncClientEvent } from './SharedSyncImplementation';
-import Logger from 'js-logger';
+import { createBaseLogger } from '@powersync/common';
 const _self = self;
-Logger.useDefaults();
+const logger = createBaseLogger();
+logger.useDefaults();
 const sharedSyncImplementation = new SharedSyncImplementation();
 _self.onconnect = function (event) {
     const port = event.ports[0];
@@ -13,7 +14,6 @@ _self.onconnect = function (event) {
     port.addEventListener('message', (event) => {
         const payload = event.data;
         if (payload?.event == SharedSyncClientEvent.CLOSE_CLIENT) {
-            console.log('closing shared for port', port);
             sharedSyncImplementation.removePort(port);
         }
     });