@powersync/web 1.38.6 → 1.39.0

package/dist/index.umd.js

@@ -1564,6 +1564,198 @@ class Lock {
 }
 
 
+/***/ },
+
+/***/ "../../node_modules/.pnpm/@journeyapps+wa-sqlite@1.7.0/node_modules/@journeyapps/wa-sqlite/src/examples/MemoryVFS.js"
+/*!***************************************************************************************************************************!*\
+  !*** ../../node_modules/.pnpm/@journeyapps+wa-sqlite@1.7.0/node_modules/@journeyapps/wa-sqlite/src/examples/MemoryVFS.js ***!
+  \***************************************************************************************************************************/
+(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   MemoryVFS: () => (/* binding */ MemoryVFS)
+/* harmony export */ });
+/* harmony import */ var _FacadeVFS_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../FacadeVFS.js */ "../../node_modules/.pnpm/@journeyapps+wa-sqlite@1.7.0/node_modules/@journeyapps/wa-sqlite/src/FacadeVFS.js");
+/* harmony import */ var _VFS_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../VFS.js */ "../../node_modules/.pnpm/@journeyapps+wa-sqlite@1.7.0/node_modules/@journeyapps/wa-sqlite/src/VFS.js");
+// Copyright 2024 Roy T. Hashimoto. All Rights Reserved.
+
+
+
+// Sample in-memory filesystem.
+class MemoryVFS extends _FacadeVFS_js__WEBPACK_IMPORTED_MODULE_0__.FacadeVFS {
+  // Map of existing files, keyed by filename.
+  mapNameToFile = new Map();
+
+  // Map of open files, keyed by id (sqlite3_file pointer).
+  mapIdToFile = new Map();
+
+  static async create(name, module) {
+    const vfs = new MemoryVFS(name, module);
+    await vfs.isReady();
+    return vfs;
+  }
+
+  constructor(name, module) {
+    super(name, module);
+  }
+
+  close() {
+    for (const fileId of this.mapIdToFile.keys()) {
+      this.jClose(fileId);
+    }
+  }
+
+  /**
+   * @param {string?} filename 
+   * @param {number} fileId 
+   * @param {number} flags 
+   * @param {DataView} pOutFlags 
+   * @returns {number|Promise<number>}
+   */
+  jOpen(filename, fileId, flags, pOutFlags) {
+    const url = new URL(filename || Math.random().toString(36).slice(2), 'file://');
+    const pathname = url.pathname;
+
+    let file = this.mapNameToFile.get(pathname);
+    if (!file) {
+      if (flags & _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OPEN_CREATE) {
+        // Create a new file object.
+        file = {
+          pathname,
+          flags,
+          size: 0,
+          data: new ArrayBuffer(0)
+        };
+        this.mapNameToFile.set(pathname, file);
+      } else {
+        return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_CANTOPEN;
+      }
+    }
+
+    // Put the file in the opened files map.
+    this.mapIdToFile.set(fileId, file);
+    pOutFlags.setInt32(0, flags, true);
+    return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+  }
+
+  /**
+   * @param {number} fileId 
+   * @returns {number|Promise<number>}
+   */
+  jClose(fileId) {
+    const file = this.mapIdToFile.get(fileId);
+    this.mapIdToFile.delete(fileId);
+
+    if (file.flags & _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OPEN_DELETEONCLOSE) {
+      this.mapNameToFile.delete(file.pathname);
+    }
+    return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+  }
+
+  /**
+   * @param {number} fileId 
+   * @param {Uint8Array} pData 
+   * @param {number} iOffset
+   * @returns {number|Promise<number>}
+   */
+  jRead(fileId, pData, iOffset) {
+    const file = this.mapIdToFile.get(fileId);
+
+    // Clip the requested read to the file boundary.
+    const bgn = Math.min(iOffset, file.size);
+    const end = Math.min(iOffset + pData.byteLength, file.size);
+    const nBytes = end - bgn;
+
+    if (nBytes) {
+      pData.set(new Uint8Array(file.data, bgn, nBytes));
+    }
+
+    if (nBytes < pData.byteLength) {
+      // Zero unused area of read buffer.
+      pData.fill(0, nBytes);
+      return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_IOERR_SHORT_READ;
+    }
+    return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+  }
+
+  /**
+   * @param {number} fileId 
+   * @param {Uint8Array} pData 
+   * @param {number} iOffset
+   * @returns {number|Promise<number>}
+   */
+  jWrite(fileId, pData, iOffset) {
+    const file = this.mapIdToFile.get(fileId);
+    if (iOffset + pData.byteLength > file.data.byteLength) {
+      // Resize the ArrayBuffer to hold more data.
+      const newSize = Math.max(iOffset + pData.byteLength, 2 * file.data.byteLength);
+      const data = new ArrayBuffer(newSize);
+      new Uint8Array(data).set(new Uint8Array(file.data, 0, file.size));
+      file.data = data;
+    }
+
+    // Copy data.
+    new Uint8Array(file.data, iOffset, pData.byteLength).set(pData.subarray());
+    file.size = Math.max(file.size, iOffset + pData.byteLength);
+    return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+  }
+
+  /**
+   * @param {number} fileId 
+   * @param {number} iSize 
+   * @returns {number|Promise<number>}
+   */
+  jTruncate(fileId, iSize) {
+    const file = this.mapIdToFile.get(fileId);
+
+    // For simplicity we don't make the ArrayBuffer smaller.
+    file.size = Math.min(file.size, iSize);
+    return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+  }
+
+  /**
+   * @param {number} fileId 
+   * @param {DataView} pSize64 
+   * @returns {number|Promise<number>}
+   */
+  jFileSize(fileId, pSize64) {
+    const file = this.mapIdToFile.get(fileId);
+
+    pSize64.setBigInt64(0, BigInt(file.size), true);
+    return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+  }
+
+  /**
+   * @param {string} name 
+   * @param {number} syncDir 
+   * @returns {number|Promise<number>}
+   */
+  jDelete(name, syncDir) {
+    const url = new URL(name, 'file://');
+    const pathname = url.pathname;
+
+    this.mapNameToFile.delete(pathname);
+    return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+  }
+
+  /**
+   * @param {string} name 
+   * @param {number} flags 
+   * @param {DataView} pResOut 
+   * @returns {number|Promise<number>}
+   */
+  jAccess(name, flags, pResOut) {
+    const url = new URL(name, 'file://');
+    const pathname = url.pathname;
+
+    const file = this.mapNameToFile.get(pathname);
+    pResOut.setInt32(0, file ? 1 : 0, true);
+    return _VFS_js__WEBPACK_IMPORTED_MODULE_1__.SQLITE_OK;
+  }
+}
+
+
 /***/ },
 
 /***/ "../../node_modules/.pnpm/@journeyapps+wa-sqlite@1.7.0/node_modules/@journeyapps/wa-sqlite/src/examples/OPFSWriteAheadVFS.js"
@@ -5469,10 +5661,8 @@ class RawSqliteConnection {
      * The `sqlite3*` connection pointer.
      */
     db = 0;
-    _moduleFactory;
     constructor(options) {
         this.options = options;
-        this._moduleFactory = _vfs_js__WEBPACK_IMPORTED_MODULE_1__.DEFAULT_MODULE_FACTORIES[this.options.vfs];
     }
     get isOpen() {
         return this.db != 0;
@@ -5482,17 +5672,14 @@ class RawSqliteConnection {
         this.db = await api.open_v2(this.options.dbFilename, this.options.isReadOnly ? 1 /* SQLITE_OPEN_READONLY */ : 6 /* SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE */);
         await this.executeRaw(`PRAGMA temp_store = ${this.options.temporaryStorage};`);
         if (this.options.encryptionKey) {
-            const escapedKey = this.options.encryptionKey.replace("'", "''");
-            await this.executeRaw(`PRAGMA key = '${escapedKey}'`);
+            const escapedKey = this.options.encryptionKey.replaceAll("'", "''");
+            await this.executeRaw(`PRAGMA key = '${escapedKey}';`);
         }
         await this.executeRaw(`PRAGMA cache_size = -${this.options.cacheSizeKb};`);
         await this.executeRaw(`SELECT powersync_update_hooks('install');`);
     }
     async openSQLiteAPI() {
-        const { module, vfs } = await this._moduleFactory({
-            dbFileName: this.options.dbFilename,
-            encryptionKey: this.options.encryptionKey
-        });
+        const { module, vfs } = await (0,_vfs_js__WEBPACK_IMPORTED_MODULE_1__.loadModuleAndVfs)(this.options);
         const sqlite3 = (0,_journeyapps_wa_sqlite__WEBPACK_IMPORTED_MODULE_0__.Factory)(module);
         sqlite3.vfs_register(vfs, true);
         /**
@@ -5820,8 +6007,8 @@ class WASQLitePowerSyncDatabaseOpenFactory extends _AbstractWebPowerSyncDatabase
 
 __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   DEFAULT_MODULE_FACTORIES: () => (/* binding */ DEFAULT_MODULE_FACTORIES),
 /* harmony export */   WASQLiteVFS: () => (/* binding */ WASQLiteVFS),
+/* harmony export */   loadModuleAndVfs: () => (/* binding */ loadModuleAndVfs),
 /* harmony export */   vfsRequiresDedicatedWorkers: () => (/* binding */ vfsRequiresDedicatedWorkers)
 /* harmony export */ });
 /**
@@ -5833,9 +6020,26 @@ var WASQLiteVFS;
     WASQLiteVFS["OPFSCoopSyncVFS"] = "OPFSCoopSyncVFS";
     WASQLiteVFS["AccessHandlePoolVFS"] = "AccessHandlePoolVFS";
     WASQLiteVFS["OPFSWriteAheadVFS"] = "OPFSWriteAheadVFS";
+    /**
+     * A virtual file system storing data in-memory only, without persistence.
+     *
+     * This file system can be used in three configurations:
+     *
+     * 1. In shared workers (the default when available): All tabs share the same in-memory database, which is cleared
+     *    once the last tab is closed.
+     * 2. In dedicated workers (used when `enableMultiTabs` is disabled). Each tab has its own in-memory database cleared
+     *    when the tab is closed. Queries are offloaded to a dedicated worker.
+     * 3. In the context of the tab itself (used when both `enableMultiTabs` and `useWebWorker` are disabled). The per-tab
+     *    database is hosted in the tab itself, and queries run synchronously. This is _a lot_ faster than any other
+     *    single-threadedVFS, but can block JavaScript for computationally-intensive queries.
+     *
+     * This VFS primarily intended for development, but it also useful for online-first deployments not syncing large
+     * amounts of data, as it is quicker to start up.
+     */
+    WASQLiteVFS["InMemoryVfs"] = "InMemoryVFS";
 })(WASQLiteVFS || (WASQLiteVFS = {}));
 function vfsRequiresDedicatedWorkers(vfs) {
-    return vfs != WASQLiteVFS.IDBBatchAtomicVFS;
+    return vfs != WASQLiteVFS.IDBBatchAtomicVFS && vfs != WASQLiteVFS.InMemoryVfs;
 }
 async function asyncModuleFactory(encryptionKey) {
     if (encryptionKey) {
@@ -5860,46 +6064,47 @@ async function syncModuleFactory(encryptionKey) {
 /**
  * @internal
  */
-const DEFAULT_MODULE_FACTORIES = {
-    [WASQLiteVFS.IDBBatchAtomicVFS]: async (options) => {
-        const module = await asyncModuleFactory(options.encryptionKey);
-        const { IDBBatchAtomicVFS } = await Promise.resolve(/*! import() */).then(__webpack_require__.t.bind(__webpack_require__, /*! @journeyapps/wa-sqlite/src/examples/IDBBatchAtomicVFS.js */ "@journeyapps/wa-sqlite/src/examples/IDBBatchAtomicVFS.js", 19));
-        return {
-            module,
+async function loadModuleAndVfs({ vfs, dbFilename, encryptionKey }) {
+    let moduleFactory = syncModuleFactory;
+    let resolveVfs;
+    switch (vfs) {
+        case WASQLiteVFS.IDBBatchAtomicVFS: {
+            moduleFactory = asyncModuleFactory;
+            const { IDBBatchAtomicVFS } = await Promise.resolve(/*! import() */).then(__webpack_require__.t.bind(__webpack_require__, /*! @journeyapps/wa-sqlite/src/examples/IDBBatchAtomicVFS.js */ "@journeyapps/wa-sqlite/src/examples/IDBBatchAtomicVFS.js", 19));
+            resolveVfs = (module) => {
+                // @ts-expect-error The types for this static method are missing upstream
+                return IDBBatchAtomicVFS.create(dbFilename, module, { lockPolicy: 'exclusive' });
+            };
+            break;
+        }
+        case WASQLiteVFS.AccessHandlePoolVFS: {
+            // @ts-expect-error The types for this import are missing upstream
+            const { AccessHandlePoolVFS } = await Promise.resolve(/*! import() */).then(__webpack_require__.t.bind(__webpack_require__, /*! @journeyapps/wa-sqlite/src/examples/AccessHandlePoolVFS.js */ "@journeyapps/wa-sqlite/src/examples/AccessHandlePoolVFS.js", 19));
+            resolveVfs = (module) => AccessHandlePoolVFS.create(dbFilename, module);
+            break;
+        }
+        case WASQLiteVFS.OPFSCoopSyncVFS: {
+            // @ts-expect-error The types for this import are missing upstream
+            const { OPFSCoopSyncVFS } = await Promise.resolve(/*! import() */).then(__webpack_require__.t.bind(__webpack_require__, /*! @journeyapps/wa-sqlite/src/examples/OPFSCoopSyncVFS.js */ "@journeyapps/wa-sqlite/src/examples/OPFSCoopSyncVFS.js", 19));
+            resolveVfs = (module) => OPFSCoopSyncVFS.create(dbFilename, module);
+            break;
+        }
+        case WASQLiteVFS.OPFSWriteAheadVFS: {
+            // @ts-expect-error The types for this import are missing upstream
+            const { OPFSWriteAheadVFS } = await Promise.resolve(/*! import() */).then(__webpack_require__.bind(__webpack_require__, /*! @journeyapps/wa-sqlite/src/examples/OPFSWriteAheadVFS.js */ "../../node_modules/.pnpm/@journeyapps+wa-sqlite@1.7.0/node_modules/@journeyapps/wa-sqlite/src/examples/OPFSWriteAheadVFS.js"));
+            resolveVfs = (module) => OPFSWriteAheadVFS.create(dbFilename, module, {});
+            break;
+        }
+        case WASQLiteVFS.InMemoryVfs: {
+            const { MemoryVFS } = await Promise.resolve(/*! import() */).then(__webpack_require__.bind(__webpack_require__, /*! @journeyapps/wa-sqlite/src/examples/MemoryVFS.js */ "../../node_modules/.pnpm/@journeyapps+wa-sqlite@1.7.0/node_modules/@journeyapps/wa-sqlite/src/examples/MemoryVFS.js"));
             // @ts-expect-error The types for this static method are missing upstream
-            vfs: await IDBBatchAtomicVFS.create(options.dbFileName, module, { lockPolicy: 'exclusive' })
-        };
-    },
-    [WASQLiteVFS.AccessHandlePoolVFS]: async (options) => {
-        const module = await syncModuleFactory(options.encryptionKey);
-        // @ts-expect-error The types for this static method are missing upstream
-        const { AccessHandlePoolVFS } = await Promise.resolve(/*! import() */).then(__webpack_require__.t.bind(__webpack_require__, /*! @journeyapps/wa-sqlite/src/examples/AccessHandlePoolVFS.js */ "@journeyapps/wa-sqlite/src/examples/AccessHandlePoolVFS.js", 19));
-        return {
-            module,
-            vfs: await AccessHandlePoolVFS.create(options.dbFileName, module)
-        };
-    },
-    [WASQLiteVFS.OPFSCoopSyncVFS]: async (options) => {
-        const module = await syncModuleFactory(options.encryptionKey);
-        // @ts-expect-error The types for this static method are missing upstream
-        const { OPFSCoopSyncVFS } = await Promise.resolve(/*! import() */).then(__webpack_require__.t.bind(__webpack_require__, /*! @journeyapps/wa-sqlite/src/examples/OPFSCoopSyncVFS.js */ "@journeyapps/wa-sqlite/src/examples/OPFSCoopSyncVFS.js", 19));
-        const vfs = await OPFSCoopSyncVFS.create(options.dbFileName, module);
-        return {
-            module,
-            vfs
-        };
-    },
-    [WASQLiteVFS.OPFSWriteAheadVFS]: async (options) => {
-        const module = await syncModuleFactory(options.encryptionKey);
-        // @ts-expect-error The types for this static method are missing upstream
-        const { OPFSWriteAheadVFS } = await Promise.resolve(/*! import() */).then(__webpack_require__.bind(__webpack_require__, /*! @journeyapps/wa-sqlite/src/examples/OPFSWriteAheadVFS.js */ "../../node_modules/.pnpm/@journeyapps+wa-sqlite@1.7.0/node_modules/@journeyapps/wa-sqlite/src/examples/OPFSWriteAheadVFS.js"));
-        const vfs = await OPFSWriteAheadVFS.create(options.dbFileName, module, {});
-        return {
-            module,
-            vfs
-        };
+            resolveVfs = (module) => MemoryVFS.create(dbFilename, module);
+            break;
+        }
     }
-};
+    const module = await moduleFactory(encryptionKey);
+    return { module, vfs: await resolveVfs(module) };
+}
 
 
 /***/ },
@@ -6517,6 +6722,8 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var _shared_navigator_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../../shared/navigator.js */ "./lib/src/shared/navigator.js");
 /* harmony import */ var _db_adapters_wa_sqlite_RawSqliteConnection_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../../db/adapters/wa-sqlite/RawSqliteConnection.js */ "./lib/src/db/adapters/wa-sqlite/RawSqliteConnection.js");
 /* harmony import */ var _db_adapters_wa_sqlite_ConcurrentConnection_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../../db/adapters/wa-sqlite/ConcurrentConnection.js */ "./lib/src/db/adapters/wa-sqlite/ConcurrentConnection.js");
+/* harmony import */ var _db_adapters_wa_sqlite_vfs_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../../db/adapters/wa-sqlite/vfs.js */ "./lib/src/db/adapters/wa-sqlite/vfs.js");
+
 
 
 
@@ -6565,13 +6772,14 @@ class MultiDatabaseServer {
     }
     async databaseOpenAttempt(options) {
         return (0,_shared_navigator_js__WEBPACK_IMPORTED_MODULE_2__.getNavigatorLocks)().request(OPEN_DB_LOCK, async () => {
-            const { dbFilename } = options;
+            const { dbFilename, isReadOnly, vfs } = options;
             let server = this.activeDatabases.get(dbFilename);
             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).
-                const needsNavigatorLocks = !(isSharedWorker || options.isReadOnly);
+                // 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 == _db_adapters_wa_sqlite_vfs_js__WEBPACK_IMPORTED_MODULE_5__.WASQLiteVFS.InMemoryVfs);
                 const connection = new _db_adapters_wa_sqlite_RawSqliteConnection_js__WEBPACK_IMPORTED_MODULE_3__.RawSqliteConnection(options);
                 const withSafeConcurrency = new _db_adapters_wa_sqlite_ConcurrentConnection_js__WEBPACK_IMPORTED_MODULE_4__.ConcurrentSqliteConnection(connection, needsNavigatorLocks);
                 // Initializing the RawSqliteConnection will run some pragmas that might write to the database file, so we want