@powersync/web 0.6.1 → 0.8.0

package/README.md

@@ -56,6 +56,14 @@ if (typeof self.Buffer == 'undefined') {
 }
 ```
 
+## Webpack
+
+See the [example Webpack config](https://github.com/powersync-ja/powersync-js/blob/main/demos/example-webpack/webpack.config.js) for details on polyfills and requirements.
+
+## Vite
+
+See the [example Vite config](https://github.com/powersync-ja/powersync-js/blob/main/demos/example-vite/vite.config.ts) for details on polyfills and requirements.
+
 # Getting Started
 
 Our [full SDK reference](https://docs.powersync.com/client-sdk-references/js-web) contains everything you need to know to get started implementing PowerSync in your project.

package/lib/src/db/PowerSyncDatabase.d.ts

@@ -1,10 +1,11 @@
-import { AbstractPowerSyncDatabase, AbstractStreamingSyncImplementation, PowerSyncBackendConnector, BucketStorageAdapter, PowerSyncDatabaseOptions, PowerSyncCloseOptions, PowerSyncConnectionOptions } from '@powersync/common';
+import { type AbstractStreamingSyncImplementation, type PowerSyncBackendConnector, type BucketStorageAdapter, type PowerSyncDatabaseOptions, type PowerSyncCloseOptions, type PowerSyncConnectionOptions, AbstractPowerSyncDatabase } from '@powersync/common';
 import { Mutex } from 'async-mutex';
 export interface WebPowerSyncFlags {
     /**
      * Enables multi tab support
      */
     enableMultiTabs?: boolean;
+    useWebWorker?: boolean;
     /**
      * Open in SSR placeholder mode. DB operations and Sync operations will be a No-op
      */

package/lib/src/db/PowerSyncDatabase.js

@@ -8,11 +8,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { AbstractPowerSyncDatabase, SqliteBucketStorage, DEFAULT_POWERSYNC_CLOSE_OPTIONS } from '@powersync/common';
+import { Mutex } from 'async-mutex';
 import { WebRemote } from './sync/WebRemote';
 import { SharedWebStreamingSyncImplementation } from './sync/SharedWebStreamingSyncImplementation';
 import { SSRStreamingSyncImplementation } from './sync/SSRWebStreamingSyncImplementation';
 import { WebStreamingSyncImplementation } from './sync/WebStreamingSyncImplementation';
-import { Mutex } from 'async-mutex';
 export class PowerSyncDatabase extends AbstractPowerSyncDatabase {
     constructor(options) {
         super(options);
@@ -76,8 +76,8 @@ export class PowerSyncDatabase extends AbstractPowerSyncDatabase {
             case flags === null || flags === void 0 ? void 0 : flags.enableMultiTabs:
                 if (!(flags === null || flags === void 0 ? void 0 : flags.broadcastLogs)) {
                     const warning = `
-Multiple tabs are enabled, but broadcasting of logs is disabled.
-Logs for shared sync worker will only be available in the shared worker context
+            Multiple tabs are enabled, but broadcasting of logs is disabled.
+            Logs for shared sync worker will only be available in the shared worker context
           `;
                     const logger = this.options.logger;
                     logger ? logger.warn(warning) : console.warn(warning);

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

@@ -2,6 +2,7 @@ import { AbstractPowerSyncDatabaseOpenFactory } from '@powersync/common';
 import { PowerSyncDatabase } from '../../db/PowerSyncDatabase';
 import { SSRDBAdapter } from './SSRDBAdapter';
 export const DEFAULT_POWERSYNC_FLAGS = {
+    useWebWorker: true,
     /**
      * Multiple tabs are by default not supported on Android, iOS and Safari.
      * Other platforms will have multiple tabs enabled by default.
@@ -48,6 +49,9 @@ export class AbstractWebPowerSyncDatabaseOpenFactory extends AbstractPowerSyncDa
         if (typeof ((_b = this.options.flags) === null || _b === void 0 ? void 0 : _b.enableMultiTabs) != 'undefined') {
             flags.enableMultiTabs = this.options.flags.enableMultiTabs;
         }
+        if (flags.useWebWorker === false) {
+            flags.enableMultiTabs = false;
+        }
         return flags;
     }
     generateInstance(options) {

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

@@ -1,6 +1,7 @@
-import { BaseObserver, DBAdapter, DBAdapterListener, DBLockOptions, LockContext, PowerSyncOpenFactoryOptions, QueryResult, Transaction } from '@powersync/common';
+import { type DBAdapter, type DBAdapterListener, type DBLockOptions, type LockContext, type PowerSyncOpenFactoryOptions, type QueryResult, type Transaction, BaseObserver } from '@powersync/common';
 export type WASQLiteFlags = {
     enableMultiTabs?: boolean;
+    useWebWorker?: boolean;
 };
 export interface WASQLiteDBAdapterOptions extends Omit<PowerSyncOpenFactoryOptions, 'schema'> {
     flags?: WASQLiteFlags;
@@ -18,7 +19,7 @@ export declare class WASQLiteDBAdapter extends BaseObserver<DBAdapterListener> i
     private initialized;
     private logger;
     private dbGetHelpers;
-    private workerMethods;
+    private methods;
     constructor(options: WASQLiteDBAdapterOptions);
     get name(): string;
     protected get flags(): WASQLiteFlags;

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

@@ -10,6 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { BaseObserver } from '@powersync/common';
 import * as Comlink from 'comlink';
 import Logger from 'js-logger';
+import { _openDB } from '../../../shared/open-db';
 import { getWorkerDatabaseOpener } from '../../../worker/db/open-worker-database';
 /**
  * Adapter for WA-SQLite
@@ -23,7 +24,7 @@ export class WASQLiteDBAdapter extends BaseObserver {
          */
         this._execute = (sql, bindings) => __awaiter(this, void 0, void 0, function* () {
             yield this.initialized;
-            const result = yield this.workerMethods.execute(sql, bindings);
+            const result = yield this.methods.execute(sql, bindings);
             return Object.assign(Object.assign({}, result), { rows: Object.assign(Object.assign({}, result.rows), { item: (idx) => result.rows._array[idx] }) });
         });
         /**
@@ -31,12 +32,12 @@ export class WASQLiteDBAdapter extends BaseObserver {
          */
         this._executeBatch = (query, params) => __awaiter(this, void 0, void 0, function* () {
             yield this.initialized;
-            const result = yield this.workerMethods.executeBatch(query, params);
+            const result = yield this.methods.executeBatch(query, params);
             return Object.assign(Object.assign({}, result), { rows: undefined });
         });
         this.logger = Logger.get('WASQLite');
         this.dbGetHelpers = null;
-        this.workerMethods = null;
+        this.methods = null;
         this.initialized = this.init();
         this.dbGetHelpers = this.generateDBHelpers({ execute: this._execute.bind(this) });
     }
@@ -50,17 +51,24 @@ export class WASQLiteDBAdapter extends BaseObserver {
     getWorker() { }
     init() {
         return __awaiter(this, void 0, void 0, function* () {
-            const { enableMultiTabs } = this.flags;
+            const { enableMultiTabs, useWebWorker } = this.flags;
             if (!enableMultiTabs) {
                 this.logger.warn('Multiple tabs are not enabled in this browser');
             }
-            const dbOpener = this.options.workerPort
-                ? Comlink.wrap(this.options.workerPort)
-                : getWorkerDatabaseOpener(this.options.dbFilename, enableMultiTabs);
-            this.workerMethods = yield dbOpener(this.options.dbFilename);
-            this.workerMethods.registerOnTableChange(Comlink.proxy((opType, tableName, rowId) => {
+            if (useWebWorker) {
+                const dbOpener = this.options.workerPort
+                    ? Comlink.wrap(this.options.workerPort)
+                    : getWorkerDatabaseOpener(this.options.dbFilename, enableMultiTabs);
+                this.methods = yield dbOpener(this.options.dbFilename);
+                this.methods.registerOnTableChange(Comlink.proxy((opType, tableName, rowId) => {
+                    this.iterateListeners((cb) => { var _a; return (_a = cb.tablesUpdated) === null || _a === void 0 ? void 0 : _a.call(cb, { opType, table: tableName, rowId }); });
+                }));
+                return;
+            }
+            this.methods = yield _openDB(this.options.dbFilename, { useWebWorker: false });
+            this.methods.registerOnTableChange((opType, tableName, rowId) => {
                 this.iterateListeners((cb) => { var _a; return (_a = cb.tablesUpdated) === null || _a === void 0 ? void 0 : _a.call(cb, { opType, table: tableName, rowId }); });
-            }));
+            });
         });
     }
     execute(query, params) {
@@ -80,7 +88,7 @@ export class WASQLiteDBAdapter extends BaseObserver {
      */
     close() {
         var _a, _b;
-        (_b = (_a = this.workerMethods) === null || _a === void 0 ? void 0 : _a.close) === null || _b === void 0 ? void 0 : _b.call(_a);
+        (_b = (_a = this.methods) === null || _a === void 0 ? void 0 : _a.close) === null || _b === void 0 ? void 0 : _b.call(_a);
     }
     getAll(sql, parameters) {
         return __awaiter(this, void 0, void 0, function* () {

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

@@ -1,3 +1,5 @@
-import { AbstractRemote } from '@powersync/common';
+import { AbstractRemote, BSONImplementation } from '@powersync/common';
 export declare class WebRemote extends AbstractRemote {
+    private _bson;
+    getBSON(): Promise<BSONImplementation>;
 }

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

@@ -1,3 +1,25 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 import { AbstractRemote } from '@powersync/common';
 export class WebRemote extends AbstractRemote {
+    getBSON() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._bson) {
+                return this._bson;
+            }
+            /**
+             * Dynamic import to be used only when needed.
+             */
+            const { BSON } = yield import('bson');
+            this._bson = BSON;
+            return this._bson;
+        });
+    }
 }

package/lib/src/shared/open-db.d.ts

@@ -0,0 +1,5 @@
+import '@journeyapps/wa-sqlite';
+import type { DBFunctionsInterface } from './types';
+export declare function _openDB(dbFileName: string, options?: {
+    useWebWorker: boolean;
+}): Promise<DBFunctionsInterface>;

package/lib/src/{worker/db → shared}/open-db.js

@@ -18,8 +18,8 @@ import * as SQLite from '@journeyapps/wa-sqlite';
 import '@journeyapps/wa-sqlite';
 import * as Comlink from 'comlink';
 let nextId = 1;
-export function _openDB(dbFileName) {
-    return __awaiter(this, void 0, void 0, function* () {
+export function _openDB(dbFileName_1) {
+    return __awaiter(this, arguments, void 0, function* (dbFileName, options = { useWebWorker: true }) {
         const { default: moduleFactory } = yield import('@journeyapps/wa-sqlite/dist/wa-sqlite-async.mjs');
         const module = yield moduleFactory();
         const sqlite3 = SQLite.Factory(module);
@@ -34,13 +34,6 @@ export function _openDB(dbFileName) {
         sqlite3.register_table_onchange_hook(db, (opType, tableName, rowId) => {
             Array.from(listeners.values()).forEach((l) => l(opType, tableName, rowId));
         });
-        const registerOnTableChange = (callback) => {
-            const id = nextId++;
-            listeners.set(id, callback);
-            return Comlink.proxy(() => {
-                listeners.delete(id);
-            });
-        };
         /**
          * This executes single SQL statements inside a requested lock.
          */
@@ -180,13 +173,35 @@ export function _openDB(dbFileName) {
                 return result;
             }));
         });
+        if (options.useWebWorker) {
+            const registerOnTableChange = (callback) => {
+                const id = nextId++;
+                listeners.set(id, callback);
+                return Comlink.proxy(() => {
+                    listeners.delete(id);
+                });
+            };
+            return {
+                execute: Comlink.proxy(execute),
+                executeBatch: Comlink.proxy(executeBatch),
+                registerOnTableChange: Comlink.proxy(registerOnTableChange),
+                close: Comlink.proxy(() => {
+                    sqlite3.close(db);
+                })
+            };
+        }
+        const registerOnTableChange = (callback) => {
+            const id = nextId++;
+            listeners.set(id, callback);
+            return () => {
+                listeners.delete(id);
+            };
+        };
         return {
-            execute: Comlink.proxy(execute),
-            executeBatch: Comlink.proxy(executeBatch),
-            registerOnTableChange: Comlink.proxy(registerOnTableChange),
-            close: Comlink.proxy(() => {
-                sqlite3.close(db);
-            })
+            execute: execute,
+            executeBatch: executeBatch,
+            registerOnTableChange: registerOnTableChange,
+            close: () => sqlite3.close(db)
         };
     });
 }

package/lib/src/{worker/db/open-db.d.ts → shared/types.d.ts}

@@ -1,20 +1,22 @@
-import '@journeyapps/wa-sqlite';
-import { QueryResult } from '@powersync/common';
+import type { QueryResult } from '@powersync/common';
 export type WASQLExecuteResult = Omit<QueryResult, 'rows'> & {
     rows: {
         _array: any[];
         length: number;
     };
 };
-export type DBWorkerInterface = {
+export type DBFunctionsInterface = {
     close?: () => void;
     execute: WASQLiteExecuteMethod;
     executeBatch: WASQLiteExecuteBatchMethod;
     registerOnTableChange: (callback: OnTableChangeCallback) => void;
 };
+/**
+ * @deprecated use [DBFunctionsInterface instead]
+ */
+export type DBWorkerInterface = DBFunctionsInterface;
 export type WASQLiteExecuteMethod = (sql: string, params?: any[]) => Promise<WASQLExecuteResult>;
 export type WASQLiteExecuteBatchMethod = (sql: string, params?: any[]) => Promise<WASQLExecuteResult>;
 export type OnTableChangeCallback = (opType: number, tableName: string, rowId: number) => void;
 export type OpenDB = (dbFileName: string) => DBWorkerInterface;
 export type SQLBatchTuple = [string] | [string, Array<any> | Array<Array<any>>];
-export declare function _openDB(dbFileName: string): Promise<DBWorkerInterface>;

package/lib/src/shared/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import '@journeyapps/wa-sqlite';
 import * as Comlink from 'comlink';
-import { _openDB } from './open-db';
+import { _openDB } from '../../shared/open-db';
 const _self = self;
 const DBMap = new Map();
 const OPEN_DB_LOCK = 'open-wasqlite-db';

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

@@ -8,5 +8,5 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import * as Comlink from 'comlink';
-import { _openDB } from './open-db';
+import { _openDB } from '../../shared/open-db';
 Comlink.expose((dbFileName) => __awaiter(void 0, void 0, void 0, function* () { return Comlink.proxy(yield _openDB(dbFileName)); }));

package/lib/src/worker/db/open-worker-database.d.ts

@@ -1,5 +1,5 @@
 import * as Comlink from 'comlink';
-import { OpenDB } from './open-db';
+import type { OpenDB } from '../../shared/types';
 /**
  * Opens a shared or dedicated worker which exposes opening of database connections
  */

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

@@ -1,4 +1,4 @@
-import { PowerSyncCredentials, SyncStatusOptions } from '@powersync/common';
+import type { PowerSyncCredentials, SyncStatusOptions } from '@powersync/common';
 /**
  * The client side port should provide these methods.
  */

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

@@ -1,4 +1,4 @@
-import { ILogLevel, ILogger } from 'js-logger';
+import { type ILogLevel, type ILogger } from 'js-logger';
 import { type WrappedSyncPort } from './SharedSyncImplementation';
 /**
  * Broadcasts logs to all clients

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

@@ -77,7 +77,7 @@ export class BroadcastLogger {
      */
     iterateClients(callback) {
         return __awaiter(this, void 0, void 0, function* () {
-            for (let client of this.clients) {
+            for (const client of this.clients) {
                 try {
                     yield callback(client);
                 }

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

@@ -1,6 +1,6 @@
 import * as Comlink from 'comlink';
-import { ILogger } from 'js-logger';
-import { AbstractStreamingSyncImplementation, StreamingSyncImplementation, BaseObserver, LockOptions, StreamingSyncImplementationListener, SyncStatus, SyncStatusOptions, PowerSyncConnectionOptions } from '@powersync/common';
+import { type ILogger } from 'js-logger';
+import { type AbstractStreamingSyncImplementation, type StreamingSyncImplementation, type LockOptions, type StreamingSyncImplementationListener, type SyncStatusOptions, type PowerSyncConnectionOptions, BaseObserver, SyncStatus } from '@powersync/common';
 import { WebStreamingSyncImplementationOptions } from '../../db/sync/WebStreamingSyncImplementation';
 import { AbstractSharedSyncClientProvider } from './AbstractSharedSyncClientProvider';
 /**